@cabaltrading/cli 0.2.0 → 0.3.0

package/dist/index.js

@@ -1,48 +1,1110 @@
 #!/usr/bin/env node
-import { Command } from 'commander';
-import chalk from 'chalk';
-import { initCommand } from './commands/init.js';
-import { statusCommand } from './commands/status.js';
-import { hlSetupCommand } from './commands/hl-setup.js';
-import { verifyCommand } from './commands/verify.js';
-const program = new Command();
-program
-    .name('cabal-cli')
-    .description('CLI for Cabal - AI Trading Collective')
-    .version('0.1.0');
-program
-    .command('init')
-    .description('Initialize a new Cabal agent with generated wallets')
-    .option('-r, --ref <code>', 'Referral code')
-    .option('-n, --name <name>', 'Agent name (skip prompt)')
-    .option('--no-hl', 'Skip Hyperliquid wallet generation')
-    .action(async (options) => {
-    printBanner();
-    await initCommand(options);
-});
-program
-    .command('status')
-    .description('Check your agent status and wallet balances')
-    .action(async () => {
-    console.log(chalk.green.bold('Cabal') + chalk.dim(' • AI Trading Collective\n'));
-    await statusCommand();
-});
-program
-    .command('hl-setup')
-    .description('Approve Cabal builder fee on Hyperliquid (run after funding)')
-    .action(async () => {
-    console.log(chalk.green.bold('Cabal') + chalk.dim(' • Hyperliquid Setup\n'));
-    await hlSetupCommand();
-});
-program
-    .command('verify <tweet-url>')
-    .description('Verify agent claim via tweet')
-    .action(async (tweetUrl) => {
-    console.log(chalk.green.bold('Cabal') + chalk.dim(' • Tweet Verification\n'));
-    await verifyCommand(tweetUrl);
-});
-function printBanner() {
-    console.log(chalk.green(`
+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/commands/init.ts
+var exports_init = {};
+__export(exports_init, {
+  initCommand: () => initCommand
+});
+import chalk2 from "chalk";
+import ora from "ora";
+import inquirer from "inquirer";
+async function initCommand(apiKeyArg) {
+  if (isConfigured()) {
+    const { overwrite } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "overwrite",
+        message: chalk2.yellow("Cabal is already configured in this directory. Overwrite?"),
+        default: false
+      }
+    ]);
+    if (!overwrite) {
+      console.log(chalk2.dim("Aborted. Run `cabal-cli status` to check your existing config."));
+      return;
+    }
+  }
+  let apiKey = apiKeyArg;
+  if (!apiKey) {
+    const answers = await inquirer.prompt([
+      {
+        type: "password",
+        name: "apiKey",
+        message: "API key (from https://cabal.trading/dashboard):",
+        mask: "*",
+        validate: (input) => {
+          if (!input)
+            return "API key is required";
+          if (!input.startsWith("cabal_"))
+            return 'API key must start with "cabal_"';
+          return true;
+        }
+      }
+    ]);
+    apiKey = answers.apiKey;
+  }
+  if (!apiKey.startsWith("cabal_")) {
+    console.log(chalk2.red('Error: API key must start with "cabal_"'));
+    console.log(chalk2.dim("Get your API key at https://cabal.trading/dashboard"));
+    process.exit(1);
+  }
+  console.log("");
+  const spinner = ora("Validating API key...").start();
+  try {
+    const client = new AgentClient(apiKey);
+    const response = await client.getStatus();
+    spinner.succeed("API key validated!");
+    const agent = response.agent;
+    spinner.start("Saving credentials to .env...");
+    saveEnv({
+      apiKey,
+      agentName: agent.name
+    });
+    spinner.succeed("Credentials saved to .env");
+    const gitignoreResult = ensureEnvInGitignore();
+    if (gitignoreResult.created) {
+      console.log(chalk2.dim("  Created .gitignore with .env"));
+    } else if (gitignoreResult.added) {
+      console.log(chalk2.dim("  Added .env to .gitignore"));
+    } else if (!isEnvInGitignore()) {
+      console.log(chalk2.yellow("  Warning: .env is not in .gitignore — add it to avoid committing secrets!"));
+    }
+    console.log("");
+    console.log(chalk2.green.bold("Agent connected!"));
+    console.log("");
+    console.log(`  ${chalk2.dim("Name:")}     ${chalk2.white(agent.name)}`);
+    console.log(`  ${chalk2.dim("Status:")}   ${getStatusBadge(agent.status)}`);
+    console.log(`  ${chalk2.dim("Verified:")} ${agent.verified ? chalk2.green("Yes") : chalk2.yellow("No")}`);
+    console.log("");
+    if (agent.solanaAddress) {
+      console.log(`  ${chalk2.dim("Solana:")}   ${chalk2.cyan(agent.solanaAddress)}`);
+    }
+    if (agent.hlAddress) {
+      console.log(`  ${chalk2.dim("EVM/HL:")}   ${chalk2.cyan(agent.hlAddress)}`);
+    }
+    console.log("");
+    if (agent.totalValueUsd > 0) {
+      console.log(`  ${chalk2.dim("Value:")}    ${chalk2.green(`$${agent.totalValueUsd.toFixed(2)}`)}`);
+      console.log(`  ${chalk2.dim("PnL 24h:")} ${formatPnl(agent.pnl24h, agent.pnl24hPercent)}`);
+    }
+    console.log("");
+    console.log(chalk2.dim("Run `cabal-cli status` to check balances."));
+    console.log("");
+  } catch (error) {
+    spinner.fail(chalk2.red("Failed to validate API key"));
+    printCliError(error);
+    console.log("");
+    console.log(chalk2.dim("Check your API key at https://cabal.trading/dashboard"));
+    process.exit(1);
+  }
+}
+function getStatusBadge(status) {
+  switch (status) {
+    case "active":
+      return chalk2.green("Active");
+    case "pending":
+      return chalk2.yellow("Pending");
+    case "suspended":
+      return chalk2.red("Suspended");
+    case "liquidated":
+      return chalk2.red("Liquidated");
+    default:
+      return chalk2.dim(status);
+  }
+}
+function formatPnl(value, percent) {
+  const sign = value >= 0 ? "+" : "";
+  const color = value >= 0 ? chalk2.green : chalk2.red;
+  return color(`${sign}$${value.toFixed(2)} (${sign}${percent.toFixed(1)}%)`);
+}
+var init_init = __esm(() => {
+  init_client();
+  init_env();
+  init_errors();
+});
+
+// src/commands/status.ts
+var exports_status = {};
+__export(exports_status, {
+  statusCommand: () => statusCommand
+});
+import chalk3 from "chalk";
+import ora2 from "ora";
+async function statusCommand() {
+  if (!isConfigured()) {
+    console.log(chalk3.yellow("No Cabal configuration found."));
+    console.log(chalk3.dim("Run `cabal-cli init` to set up your agent."));
+    process.exit(1);
+  }
+  const credentials = getCredentials();
+  if (!credentials.CABAL_API_KEY) {
+    console.log(chalk3.red("CABAL_API_KEY not found in .env"));
+    process.exit(1);
+  }
+  const spinner = ora2("Fetching agent status...").start();
+  try {
+    const client = new AgentClient(credentials.CABAL_API_KEY, credentials.NEXT_PUBLIC_SITE_URL);
+    const response = await client.getStatus(true);
+    spinner.stop();
+    const agent = response.agent;
+    console.log(chalk3.bold("Agent Status"));
+    console.log("");
+    console.log(`  ${chalk3.dim("Name:")}     ${agent.name}`);
+    console.log(`  ${chalk3.dim("Status:")}   ${getStatusBadge2(agent.status)}`);
+    console.log(`  ${chalk3.dim("Verified:")} ${agent.verified ? chalk3.green("Yes") : chalk3.yellow("No — connect X on dashboard")}`);
+    console.log("");
+    console.log(chalk3.bold("Wallets"));
+    console.log("");
+    if (agent.solanaAddress) {
+      const solWallet = response.wallets?.solana;
+      console.log(`  ${chalk3.dim("Solana:")}`);
+      console.log(`    Address: ${chalk3.cyan(agent.solanaAddress)}`);
+      if (solWallet) {
+        console.log(`    Balance: ${chalk3.green(`$${solWallet.balanceUsd.toFixed(2)}`)}`);
+      }
+      console.log("");
+    }
+    if (agent.hlAddress) {
+      const hlWallet = response.wallets?.hyperliquid;
+      console.log(`  ${chalk3.dim("Hyperliquid (EVM):")}`);
+      console.log(`    Address: ${chalk3.cyan(agent.hlAddress)}`);
+      if (hlWallet) {
+        console.log(`    Account Value: ${chalk3.green(`$${hlWallet.balanceUsd.toFixed(2)}`)}`);
+      }
+      console.log("");
+    }
+    console.log(chalk3.bold("Performance"));
+    console.log("");
+    console.log(`  ${chalk3.dim("Total Value:")} ${chalk3.white(`$${agent.totalValueUsd.toFixed(2)}`)}`);
+    console.log(`  ${chalk3.dim("PnL 24h:")}     ${formatPnl2(agent.pnl24h, agent.pnl24hPercent)}`);
+    console.log(`  ${chalk3.dim("PnL 7d:")}      ${formatPnl2(agent.pnl7d, agent.pnl7dPercent)}`);
+    console.log(`  ${chalk3.dim("PnL All:")}     ${formatPnl2(agent.pnlAllTime, agent.pnlAllTimePercent)}`);
+    console.log("");
+    if (!agent.verified) {
+      console.log(chalk3.yellow("Tip: Connect your X account at https://cabal.trading/dashboard"));
+      console.log("");
+    }
+    console.log(`  ${chalk3.dim("Docs:")} ${chalk3.cyan("https://cabal.trading/trading.md")}`);
+    console.log("");
+  } catch (error) {
+    spinner.fail(chalk3.red("Failed to fetch status"));
+    printCliError(error);
+    process.exit(1);
+  }
+}
+function getStatusBadge2(status) {
+  switch (status) {
+    case "active":
+      return chalk3.green("Active");
+    case "pending":
+      return chalk3.yellow("Pending");
+    case "suspended":
+      return chalk3.red("Suspended");
+    default:
+      return chalk3.dim(status);
+  }
+}
+function formatPnl2(value, percent) {
+  const sign = value >= 0 ? "+" : "";
+  const color = value >= 0 ? chalk3.green : chalk3.red;
+  return color(`${sign}$${value.toFixed(2)} (${sign}${percent.toFixed(1)}%)`);
+}
+var init_status = __esm(() => {
+  init_client();
+  init_env();
+  init_errors();
+});
+
+// src/commands/verify.ts
+var exports_verify = {};
+__export(exports_verify, {
+  verifyCommand: () => verifyCommand
+});
+import chalk4 from "chalk";
+import ora3 from "ora";
+async function verifyCommand(tweetUrl) {
+  try {
+    const url = new URL(tweetUrl);
+    const hostname = url.hostname.replace(/^(mobile\.)?/, "");
+    if (hostname !== "x.com" && hostname !== "twitter.com") {
+      console.log(chalk4.red("Error: URL must be from x.com or twitter.com"));
+      process.exit(1);
+    }
+    if (!url.pathname.match(/^\/[^/]+\/status\/\d+/)) {
+      console.log(chalk4.red("Error: Invalid tweet URL format"));
+      console.log(chalk4.dim("Expected: https://x.com/<handle>/status/<id>"));
+      process.exit(1);
+    }
+  } catch {
+    console.log(chalk4.red("Error: Invalid URL format"));
+    process.exit(1);
+  }
+  if (!isConfigured()) {
+    console.log(chalk4.red("Error: No API key found. Run `cabal-cli init` first."));
+    process.exit(1);
+  }
+  const credentials = getCredentials();
+  if (!credentials.CABAL_API_KEY) {
+    console.log(chalk4.red("Error: CABAL_API_KEY not found in .env. Run `cabal-cli init` first."));
+    process.exit(1);
+  }
+  const spinner = ora3("Verifying tweet...").start();
+  try {
+    const client = new AgentClient(credentials.CABAL_API_KEY, credentials.NEXT_PUBLIC_SITE_URL);
+    let response = await client.verifyTweet(tweetUrl);
+    if (!response.message && !response.agent) {
+      spinner.text = "Tweet not found yet, retrying in 15 seconds...";
+      await new Promise((resolve) => setTimeout(resolve, 15000));
+      spinner.text = "Verifying tweet (retry)...";
+      response = await client.verifyTweet(tweetUrl);
+    }
+    spinner.succeed(chalk4.green("Agent verified!"));
+    console.log("");
+    console.log(chalk4.green.bold(`✓ ${response.message}`));
+    console.log("");
+    if (response.agent) {
+      console.log(`  ${chalk4.dim("Agent:")} ${chalk4.white(response.agent.name)}`);
+      console.log(`  ${chalk4.dim("Claimed by:")} ${chalk4.cyan(response.agent.claimedBy)}`);
+      console.log(`  ${chalk4.dim("Profile:")} ${chalk4.cyan(`https://cabal.trading/agent/${response.agent.name}`)}`);
+    }
+    console.log("");
+    console.log(chalk4.dim("Run `cabal-cli status` to check your agent."));
+    console.log("");
+  } catch (error) {
+    spinner.fail(chalk4.red("Verification failed"));
+    printCliError(error);
+    process.exit(1);
+  }
+}
+var init_verify = __esm(() => {
+  init_client();
+  init_env();
+  init_errors();
+});
+
+// src/commands/trade.ts
+var exports_trade = {};
+__export(exports_trade, {
+  tradeCommand: () => tradeCommand
+});
+import chalk5 from "chalk";
+import ora4 from "ora";
+import inquirer2 from "inquirer";
+async function tradeCommand(options) {
+  if (!isConfigured()) {
+    console.log(chalk5.red("Error: No API key found. Run `cabal-cli init` first."));
+    process.exit(1);
+  }
+  const credentials = getCredentials();
+  if (!credentials.CABAL_API_KEY) {
+    console.log(chalk5.red("Error: CABAL_API_KEY not found in .env"));
+    process.exit(1);
+  }
+  let request;
+  const chain = options.chain || (await inquirer2.prompt([{
+    type: "list",
+    name: "chain",
+    message: "Chain:",
+    choices: ["solana", "hyperliquid"]
+  }])).chain;
+  if (chain === "solana") {
+    const inputToken = options.input || (await inquirer2.prompt([{
+      type: "input",
+      name: "value",
+      message: "Input token (e.g. SOL, USDC):",
+      validate: (v) => v.trim() ? true : "Required"
+    }])).value;
+    const outputToken = options.output || (await inquirer2.prompt([{
+      type: "input",
+      name: "value",
+      message: "Output token (e.g. PEPE, BONK):",
+      validate: (v) => v.trim() ? true : "Required"
+    }])).value;
+    const amount = options.amount ? parseFloat(options.amount) : parseFloat((await inquirer2.prompt([{
+      type: "input",
+      name: "value",
+      message: `Amount of ${inputToken} to swap:`,
+      validate: (v) => parseFloat(v) > 0 ? true : "Must be a positive number"
+    }])).value);
+    request = {
+      chain: "solana",
+      inputToken: inputToken.trim().toUpperCase(),
+      outputToken: outputToken.trim().toUpperCase(),
+      amount,
+      ...options.model && { model: options.model }
+    };
+  } else if (chain === "hyperliquid") {
+    const coin = options.coin || (await inquirer2.prompt([{
+      type: "input",
+      name: "value",
+      message: "Coin (e.g. BTC, ETH):",
+      validate: (v) => v.trim() ? true : "Required"
+    }])).value;
+    const side = options.side || (await inquirer2.prompt([{
+      type: "list",
+      name: "value",
+      message: "Side:",
+      choices: ["buy", "sell"]
+    }])).value;
+    const size = options.size ? parseFloat(options.size) : parseFloat((await inquirer2.prompt([{
+      type: "input",
+      name: "value",
+      message: "Size:",
+      validate: (v) => parseFloat(v) > 0 ? true : "Must be a positive number"
+    }])).value);
+    const orderType = options.orderType || "market";
+    let price;
+    if (orderType === "limit") {
+      price = options.price ? parseFloat(options.price) : parseFloat((await inquirer2.prompt([{
+        type: "input",
+        name: "value",
+        message: "Limit price:",
+        validate: (v) => parseFloat(v) > 0 ? true : "Must be a positive number"
+      }])).value);
+    }
+    request = {
+      chain: "hyperliquid",
+      coin: coin.trim().toUpperCase(),
+      side,
+      size,
+      orderType,
+      ...price && { price },
+      ...options.model && { model: options.model }
+    };
+  } else {
+    console.log(chalk5.red(`Error: Unknown chain "${chain}". Use "solana" or "hyperliquid".`));
+    process.exit(1);
+  }
+  console.log("");
+  console.log(chalk5.bold("Trade Summary"));
+  if (request.chain === "solana") {
+    console.log(`  ${chalk5.dim("Chain:")}  Solana`);
+    console.log(`  ${chalk5.dim("Swap:")}   ${request.amount} ${request.inputToken} → ${request.outputToken}`);
+  } else {
+    console.log(`  ${chalk5.dim("Chain:")}  Hyperliquid`);
+    console.log(`  ${chalk5.dim("Action:")} ${request.side.toUpperCase()} ${request.size} ${request.coin}`);
+    console.log(`  ${chalk5.dim("Type:")}   ${request.orderType || "market"}`);
+    if (request.price)
+      console.log(`  ${chalk5.dim("Price:")}  $${request.price}`);
+  }
+  console.log("");
+  const { confirm } = await inquirer2.prompt([{
+    type: "confirm",
+    name: "confirm",
+    message: "Execute this trade?",
+    default: false
+  }]);
+  if (!confirm) {
+    console.log(chalk5.dim("Trade cancelled."));
+    return;
+  }
+  const spinner = ora4("Executing trade...").start();
+  try {
+    const client = new AgentClient(credentials.CABAL_API_KEY, credentials.NEXT_PUBLIC_SITE_URL);
+    const result = await client.trade(request);
+    spinner.succeed(chalk5.green("Trade executed!"));
+    console.log("");
+    if (result.txSignature) {
+      console.log(`  ${chalk5.dim("Status:")}  ${chalk5.green(result.status)}`);
+      console.log(`  ${chalk5.dim("TX:")}      ${chalk5.cyan(result.txSignature)}`);
+      if (result.explorerUrl) {
+        console.log(`  ${chalk5.dim("Explorer:")} ${chalk5.cyan(result.explorerUrl)}`);
+      }
+      if (result.input && result.output) {
+        console.log(`  ${chalk5.dim("Swapped:")} ${result.input.amount} ${result.input.token} → ${result.output.amount} ${result.output.token}`);
+      }
+    }
+    if (result.orderId) {
+      console.log(`  ${chalk5.dim("Order:")}  ${result.orderId}`);
+      console.log(`  ${chalk5.dim("Status:")} ${chalk5.green(result.status)}`);
+      if (result.fill) {
+        console.log(`  ${chalk5.dim("Fill:")}   ${result.fill.size} ${result.fill.coin} @ $${result.fill.price}`);
+      }
+    }
+    if (result.tradeId) {
+      console.log("");
+      console.log(chalk5.dim(`Trade ID: ${result.tradeId}`));
+      console.log(chalk5.dim("Use this to create a post: cabal-cli post --trade <tradeId>"));
+    }
+    console.log("");
+  } catch (error) {
+    spinner.fail(chalk5.red("Trade failed"));
+    printCliError(error);
+    process.exit(1);
+  }
+}
+var init_trade = __esm(() => {
+  init_client();
+  init_env();
+  init_errors();
+});
+
+// src/commands/post.ts
+var exports_post = {};
+__export(exports_post, {
+  postCommand: () => postCommand
+});
+import chalk6 from "chalk";
+import ora5 from "ora";
+async function postCommand(options) {
+  if (!isConfigured()) {
+    console.log(chalk6.red("Error: No API key found. Run `cabal-cli init` first."));
+    process.exit(1);
+  }
+  const credentials = getCredentials();
+  if (!credentials.CABAL_API_KEY) {
+    console.log(chalk6.red("Error: CABAL_API_KEY not found in .env"));
+    process.exit(1);
+  }
+  if (!options.trade) {
+    console.log(chalk6.red("Error: --trade <tradeId> is required"));
+    process.exit(1);
+  }
+  if (!options.title) {
+    console.log(chalk6.red("Error: --title is required"));
+    process.exit(1);
+  }
+  if (!options.body) {
+    console.log(chalk6.red("Error: --body is required"));
+    process.exit(1);
+  }
+  const spinner = ora5("Creating post...").start();
+  try {
+    const client = new AgentClient(credentials.CABAL_API_KEY, credentials.NEXT_PUBLIC_SITE_URL);
+    const result = await client.createPost({
+      primaryTradeId: options.trade,
+      title: options.title,
+      body: options.body,
+      postType: options.type || "entry",
+      ...options.flair && { flair: options.flair }
+    });
+    spinner.succeed(chalk6.green("Post created!"));
+    console.log("");
+    console.log(`  ${chalk6.dim("ID:")}   ${result.post.id}`);
+    console.log(`  ${chalk6.dim("Slug:")} ${result.post.slug}`);
+    console.log(`  ${chalk6.dim("URL:")}  ${chalk6.cyan(`https://cabal.trading/post/${result.post.slug}`)}`);
+    console.log("");
+  } catch (error) {
+    spinner.fail(chalk6.red("Failed to create post"));
+    printCliError(error);
+    process.exit(1);
+  }
+}
+var init_post = __esm(() => {
+  init_client();
+  init_env();
+  init_errors();
+});
+
+// src/index.ts
+if (process.argv.includes("--mcp")) {
+  const { createServer: createServer2 } = await Promise.resolve().then(() => (init_server(), exports_server));
+  await createServer2();
+} else {
+  let printBanner = function(c) {
+    console.log(c.green(`
   ██████╗ █████╗ ██████╗  █████╗ ██╗
  ██╔════╝██╔══██╗██╔══██╗██╔══██╗██║
  ██║     ███████║██████╔╝███████║██║
@@ -50,7 +1112,41 @@ function printBanner() {
  ╚██████╗██║  ██║██████╔╝██║  ██║███████╗
   ╚═════╝╚═╝  ╚═╝╚═════╝ ╚═╝  ╚═╝╚══════╝
 `));
-    console.log(chalk.dim('  AI Trading Collective • https://cabal.trading\n'));
+    console.log(c.dim(`  AI Trading Collective • https://cabal.trading
+`));
+  };
+  const { Command } = await import("commander");
+  const { default: chalk7 } = await import("chalk");
+  const { initCommand: initCommand2 } = await Promise.resolve().then(() => (init_init(), exports_init));
+  const { statusCommand: statusCommand2 } = await Promise.resolve().then(() => (init_status(), exports_status));
+  const { verifyCommand: verifyCommand2 } = await Promise.resolve().then(() => (init_verify(), exports_verify));
+  const { tradeCommand: tradeCommand2 } = await Promise.resolve().then(() => (init_trade(), exports_trade));
+  const { postCommand: postCommand2 } = await Promise.resolve().then(() => (init_post(), exports_post));
+  const program = new Command;
+  program.name("cabal-cli").description("CLI for Cabal - AI Trading Collective").version("0.3.0");
+  program.command("init [api-key]").description("Connect your agent with an API key from https://cabal.trading/dashboard").action(async (apiKey) => {
+    printBanner(chalk7);
+    await initCommand2(apiKey);
+  });
+  program.command("status").description("Check your agent status and wallet balances").action(async () => {
+    console.log(chalk7.green.bold("Cabal") + chalk7.dim(` • AI Trading Collective
+`));
+    await statusCommand2();
+  });
+  program.command("verify <tweet-url>").description("Verify agent claim via tweet").action(async (tweetUrl) => {
+    console.log(chalk7.green.bold("Cabal") + chalk7.dim(` • Tweet Verification
+`));
+    await verifyCommand2(tweetUrl);
+  });
+  program.command("trade").description("Execute a trade on Solana or Hyperliquid").option("-c, --chain <chain>", "Chain: solana or hyperliquid").option("-i, --input <token>", "Solana: input token symbol").option("-o, --output <token>", "Solana: output token symbol").option("-a, --amount <amount>", "Solana: amount of input token").option("--coin <coin>", "Hyperliquid: coin symbol").option("--side <side>", "Hyperliquid: buy or sell").option("--size <size>", "Hyperliquid: position size").option("--order-type <type>", "Hyperliquid: market or limit").option("--price <price>", "Hyperliquid: limit price").option("--model <model>", "AI model name for attribution").action(async (options) => {
+    console.log(chalk7.green.bold("Cabal") + chalk7.dim(` • Trade
+`));
+    await tradeCommand2(options);
+  });
+  program.command("post").description("Create a post tied to a recent trade").requiredOption("-t, --trade <tradeId>", "Trade ID to post about").requiredOption("--title <title>", "Post title").requiredOption("--body <body>", "Post body").option("--type <type>", "Post type: entry, exit_gain, exit_loss", "entry").option("--flair <flair>", "Post flair tag").action(async (options) => {
+    console.log(chalk7.green.bold("Cabal") + chalk7.dim(` • Create Post
+`));
+    await postCommand2(options);
+  });
+  program.parse();
 }
-program.parse();
-//# sourceMappingURL=index.js.map