@toromarket/cli 0.1.0

package/dist/index.cjs

@@ -0,0 +1,578 @@
+#!/usr/bin/env node
+"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 __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
+));
+
+// src/commands/index.ts
+var import_chalk = __toESM(require("chalk"), 1);
+var import_commander = require("commander");
+var import_sdk2 = require("@toromarket/sdk");
+
+// src/client.ts
+var import_sdk = require("@toromarket/sdk");
+
+// src/config/credentials.ts
+var import_promises = require("fs/promises");
+var import_node_os = require("os");
+var import_node_path = require("path");
+var credentialsPath = (0, import_node_path.join)((0, import_node_os.homedir)(), ".toromarket", "credentials.json");
+function getCredentialsPath() {
+  return credentialsPath;
+}
+async function loadCredentials() {
+  try {
+    const raw = await (0, import_promises.readFile)(credentialsPath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function saveCredentials(credentials) {
+  await (0, import_promises.mkdir)((0, import_node_path.dirname)(credentialsPath), { recursive: true, mode: 448 });
+  await (0, import_promises.writeFile)(credentialsPath, JSON.stringify(credentials, null, 2), { encoding: "utf8", mode: 384 });
+}
+
+// src/client.ts
+async function createClient() {
+  const baseUrl = process.env.TOROMARKET_BASE_URL ?? "https://api.toromarket.io";
+  const creds = await loadCredentials();
+  return new import_sdk.ToromarketClient({
+    baseUrl,
+    ...creds?.token ? { token: creds.token } : {}
+  });
+}
+
+// src/commands/index.ts
+function print(data) {
+  const normalized = data === void 0 ? { ok: true } : data;
+  process.stdout.write(`${JSON.stringify(normalized, null, 2)}
+`);
+}
+function printError(error) {
+  if (error instanceof import_sdk2.ToromarketError) {
+    const payload = {
+      error: error.message,
+      statusCode: error.statusCode
+    };
+    if (error.code) {
+      payload.code = error.code;
+    }
+    process.stderr.write(`${import_chalk.default.red("Error:")} ${JSON.stringify(payload, null, 2)}
+`);
+  } else {
+    const msg = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`${import_chalk.default.red("Error:")} ${msg}
+`);
+  }
+}
+async function withClient(action) {
+  const program = new import_commander.Command();
+  const client = await createClient();
+  try {
+    await action(program, client);
+  } catch (error) {
+    printError(error);
+    process.exitCode = 1;
+  }
+}
+function createProgram() {
+  const program = new import_commander.Command();
+  program.name("toromarket").description("Toromarket CLI").version("0.1.0");
+  program.command("register").requiredOption("--email <email>").requiredOption("--username <username>").requiredOption("--password <password>").action(async (options) => {
+    await withClient(async (_, client) => {
+      const auth = await client.auth.register(options);
+      await saveAuth(auth, options.email);
+      print(auth);
+    });
+  });
+  program.command("login").requiredOption("--email <email>").requiredOption("--password <password>").action(async (options) => {
+    await withClient(async (_, client) => {
+      const auth = await client.auth.login(options);
+      await saveAuth(auth, options.email);
+      print(auth);
+    });
+  });
+  const markets = program.command("markets").description("Prediction markets");
+  markets.command("list").action(async () => {
+    await withClient(async (_, client) => {
+      print(await client.predictions.listMarkets());
+    });
+  });
+  markets.command("get").argument("<marketId>").action(async (marketId) => {
+    await withClient(async (_, client) => {
+      print(await client.predictions.getMarket(marketId));
+    });
+  });
+  markets.command("trades").argument("<marketId>").option("--limit <limit>").option("--offset <offset>").action(async (marketId, options) => {
+    await withClient(async (_, client) => {
+      print(await client.predictions.getMarketTrades(marketId, {
+        ...options.limit ? { limit: Number(options.limit) } : {},
+        ...options.offset ? { offset: Number(options.offset) } : {}
+      }));
+    });
+  });
+  markets.command("positions").argument("<marketId>").action(async (marketId) => {
+    await withClient(async (_, client) => {
+      print(await client.predictions.getMarketPositions(marketId));
+    });
+  });
+  markets.command("orders").argument("<marketId>").action(async (marketId) => {
+    await withClient(async (_, client) => {
+      print(await client.predictions.getMarketOrders(marketId));
+    });
+  });
+  program.command("buy").argument("<marketId>").requiredOption("--outcome-id <outcomeId>").requiredOption("--shares <shares>").requiredOption("--price <price>").action(async (marketId, options) => {
+    await placePredictionOrder(marketId, "BUY", options);
+  });
+  program.command("sell").argument("<marketId>").requiredOption("--outcome-id <outcomeId>").requiredOption("--shares <shares>").requiredOption("--price <price>").action(async (marketId, options) => {
+    await placePredictionOrder(marketId, "SELL", options);
+  });
+  const orders = program.command("orders").description("Prediction orders");
+  orders.command("cancel").argument("<marketId>").argument("<orderId>").action(async (marketId, orderId) => {
+    await withClient(async (_, client) => {
+      print(await client.predictions.cancelOrder(marketId, orderId));
+    });
+  });
+  const crypto = program.command("crypto").description("Crypto markets");
+  crypto.command("list").action(async () => {
+    await withClient(async (_, client) => {
+      print(await client.markets.list());
+    });
+  });
+  crypto.command("buy").argument("<symbol>").requiredOption("--quantity <quantity>").action(async (symbol, options) => {
+    await tradeCrypto(symbol, "BUY", options.quantity);
+  });
+  crypto.command("sell").argument("<symbol>").requiredOption("--quantity <quantity>").action(async (symbol, options) => {
+    await tradeCrypto(symbol, "SELL", options.quantity);
+  });
+  crypto.command("get").argument("<symbol>").action(async (symbol) => {
+    await withClient(async (_, client) => {
+      print(await client.markets.get(symbol));
+    });
+  });
+  crypto.command("klines").argument("<symbol>").option("--interval <interval>", "e.g. 1h, 4h, 1d").option("--limit <limit>").action(async (symbol, options) => {
+    await withClient(async (_, client) => {
+      print(await client.markets.getKlines(symbol, {
+        ...options.interval ? { interval: options.interval } : {},
+        ...options.limit ? { limit: Number(options.limit) } : {}
+      }));
+    });
+  });
+  crypto.command("movers").action(async () => {
+    await withClient(async (_, client) => {
+      print(await client.markets.getMovers());
+    });
+  });
+  program.command("portfolio").action(async () => {
+    await withClient(async (_, client) => {
+      print(await client.portfolio.get());
+    });
+  });
+  program.command("positions").action(async () => {
+    await withClient(async (_, client) => {
+      print(await client.predictions.getPositions());
+    });
+  });
+  program.command("balance").action(async () => {
+    await withClient(async (_, client) => {
+      const portfolio = await client.portfolio.get();
+      print({ balance: portfolio.balance ?? null, totalValue: portfolio.totalValue ?? null });
+    });
+  });
+  program.command("trades").option("--limit <limit>").option("--offset <offset>").action(async (options) => {
+    await withClient(async (_, client) => {
+      print(await client.portfolio.getTrades({
+        ...options.limit ? { limit: Number(options.limit) } : {},
+        ...options.offset ? { offset: Number(options.offset) } : {}
+      }));
+    });
+  });
+  program.command("open-orders").action(async () => {
+    await withClient(async (_, client) => {
+      print(await client.portfolio.getOpenOrders());
+    });
+  });
+  program.command("portfolio-metrics").action(async () => {
+    await withClient(async (_, client) => {
+      print(await client.portfolio.getMetrics());
+    });
+  });
+  program.command("comment").argument("<marketId>").argument("<content>").action(async (marketId, content) => {
+    await withClient(async (_, client) => {
+      print(await client.chat.post(`PRED-${marketId}`, { content }));
+    });
+  });
+  const funds = program.command("funds").description("Fund actions");
+  funds.command("list").action(async () => {
+    await withClient(async (_, client) => {
+      print(await client.funds.list());
+    });
+  });
+  funds.command("join").argument("<fundId>").requiredOption("--stake <stake>").option("--invite-code <inviteCode>").action(async (fundId, options) => {
+    await withClient(async (_, client) => {
+      print(
+        await client.funds.join(fundId, {
+          stake: Number(options.stake),
+          ...options.inviteCode ? { inviteCode: options.inviteCode } : {}
+        })
+      );
+    });
+  });
+  funds.command("create").requiredOption("--name <name>").requiredOption("--description <description>").requiredOption("--initial-stake <initialStake>").option("--invite-only").option("--min-stake <minStakeToJoin>").option("--invite-code <inviteCode>").action(
+    async (options) => {
+      await withClient(async (_, client) => {
+        print(
+          await client.funds.create({
+            name: options.name,
+            description: options.description,
+            initialStake: Number(options.initialStake),
+            ...options.inviteOnly ? { inviteOnly: true } : {},
+            ...options.minStake ? { minStakeToJoin: Number(options.minStake) } : {},
+            ...options.inviteCode ? { inviteCode: options.inviteCode } : {}
+          })
+        );
+      });
+    }
+  );
+  funds.command("message").argument("<fundId>").argument("<content>").action(async (fundId, content) => {
+    await withClient(async (_, client) => {
+      print(await client.funds.chat(fundId, { content }));
+    });
+  });
+  funds.command("members").argument("<fundId>").action(async (fundId) => {
+    await withClient(async (_, client) => {
+      print(await client.funds.members(fundId));
+    });
+  });
+  funds.command("set-role").argument("<fundId>").requiredOption("--user-id <targetUserId>").requiredOption("--role <role>").action(
+    async (fundId, options) => {
+      await withClient(async (_, client) => {
+        print(
+          await client.funds.updateMemberRole(fundId, {
+            targetUserId: options.targetUserId,
+            role: options.role
+          })
+        );
+      });
+    }
+  );
+  funds.command("remove-member").argument("<fundId>").requiredOption("--user-id <userId>").action(async (fundId, options) => {
+    await withClient(async (_, client) => {
+      print(await client.funds.removeMember(fundId, options.userId));
+    });
+  });
+  funds.command("transfer-ownership").argument("<fundId>").requiredOption("--target-user-id <targetUserId>").action(async (fundId, options) => {
+    await withClient(async (_, client) => {
+      print(await client.funds.transferOwnership(fundId, { targetUserId: options.targetUserId }));
+    });
+  });
+  funds.command("leave").argument("<fundId>").action(async (fundId) => {
+    await withClient(async (_, client) => {
+      print(await client.funds.leave(fundId));
+    });
+  });
+  funds.command("chat").argument("<fundId>").option("--cursor <cursor>").option("--limit <limit>").action(async (fundId, options) => {
+    await withClient(async (_, client) => {
+      print(
+        await client.funds.chatHistory(fundId, {
+          ...options.cursor ? { cursor: options.cursor } : {},
+          ...options.limit ? { limit: Number(options.limit) } : {}
+        })
+      );
+    });
+  });
+  funds.command("get").argument("<fundId>").action(async (fundId) => {
+    await withClient(async (_, client) => {
+      print(await client.funds.get(fundId));
+    });
+  });
+  funds.command("positions").argument("<fundId>").action(async (fundId) => {
+    await withClient(async (_, client) => {
+      print(await client.funds.positions(fundId));
+    });
+  });
+  funds.command("prediction-positions").argument("<fundId>").action(async (fundId) => {
+    await withClient(async (_, client) => {
+      print(await client.funds.predictionPositions(fundId));
+    });
+  });
+  funds.command("orders").argument("<fundId>").action(async (fundId) => {
+    await withClient(async (_, client) => {
+      print(await client.funds.predictionOrders(fundId));
+    });
+  });
+  funds.command("trades").argument("<fundId>").option("--limit <limit>").option("--offset <offset>").action(async (fundId, options) => {
+    await withClient(async (_, client) => {
+      print(await client.funds.trades(fundId, {
+        ...options.limit ? { limit: Number(options.limit) } : {},
+        ...options.offset ? { offset: Number(options.offset) } : {}
+      }));
+    });
+  });
+  funds.command("cancel-order").argument("<fundId>").argument("<orderId>").action(async (fundId, orderId) => {
+    await withClient(async (_, client) => {
+      print(await client.funds.cancelPredictionOrder(fundId, orderId));
+    });
+  });
+  funds.command("buy").argument("<fundId>").argument("<marketId>").requiredOption("--outcome-id <outcomeId>").requiredOption("--shares <shares>").requiredOption("--price <price>").action(async (fundId, marketId, options) => {
+    await withClient(async (_, client) => {
+      print(await client.funds.placePredictionOrder(fundId, {
+        marketId,
+        outcomeId: options.outcomeId,
+        side: "BUY",
+        type: "LIMIT",
+        price: Number(options.price),
+        quantity: Number(options.shares)
+      }));
+    });
+  });
+  funds.command("sell").argument("<fundId>").argument("<marketId>").requiredOption("--outcome-id <outcomeId>").requiredOption("--shares <shares>").requiredOption("--price <price>").action(async (fundId, marketId, options) => {
+    await withClient(async (_, client) => {
+      print(await client.funds.placePredictionOrder(fundId, {
+        marketId,
+        outcomeId: options.outcomeId,
+        side: "SELL",
+        type: "LIMIT",
+        price: Number(options.price),
+        quantity: Number(options.shares)
+      }));
+    });
+  });
+  funds.command("crypto-buy").argument("<fundId>").argument("<symbol>").requiredOption("--quantity <quantity>").action(async (fundId, symbol, options) => {
+    await withClient(async (_, client) => {
+      print(await client.funds.tradeCrypto(fundId, { symbol, side: "BUY", quantity: Number(options.quantity) }));
+    });
+  });
+  funds.command("crypto-sell").argument("<fundId>").argument("<symbol>").requiredOption("--quantity <quantity>").action(async (fundId, symbol, options) => {
+    await withClient(async (_, client) => {
+      print(await client.funds.tradeCrypto(fundId, { symbol, side: "SELL", quantity: Number(options.quantity) }));
+    });
+  });
+  program.command("search").argument("<query>").option("--limit <limit>").option("--offset <offset>").action(async (query, options) => {
+    await withClient(async (_, client) => {
+      print(await client.search.query(query, {
+        ...options.limit ? { limit: Number(options.limit) } : {},
+        ...options.offset ? { offset: Number(options.offset) } : {}
+      }));
+    });
+  });
+  program.command("leaderboard").option("--category <category>").option("--sort <sort>").action(async (options) => {
+    await withClient(async (_, client) => {
+      const params = {};
+      if (options.category) {
+        params.category = options.category;
+      }
+      if (options.sort) {
+        params.sort = options.sort;
+      }
+      print(await client.leaderboards.get(params));
+    });
+  });
+  program.command("profile").argument("<username>").action(async (username) => {
+    await withClient(async (_, client) => {
+      print(await client.profiles.get(username));
+    });
+  });
+  program.command("follow").argument("<userId>").action(async (userId) => {
+    await withClient(async (_, client) => {
+      print(await client.social.follow(userId));
+    });
+  });
+  program.command("unfollow").argument("<userId>").action(async (userId) => {
+    await withClient(async (_, client) => {
+      print(await client.social.unfollow(userId));
+    });
+  });
+  program.command("followers").action(async () => {
+    await withClient(async (_, client) => {
+      print(await client.social.followers());
+    });
+  });
+  program.command("following").action(async () => {
+    await withClient(async (_, client) => {
+      print(await client.social.following());
+    });
+  });
+  const watchlist = program.command("watchlist").description("Watchlist");
+  watchlist.command("list").action(async () => {
+    await withClient(async (_, client) => {
+      print(await client.watchlist.list());
+    });
+  });
+  watchlist.command("add").argument("<symbol>").action(async (symbol) => {
+    await withClient(async (_, client) => {
+      print(await client.watchlist.add(symbol));
+    });
+  });
+  watchlist.command("remove").argument("<symbol>").action(async (symbol) => {
+    await withClient(async (_, client) => {
+      print(await client.watchlist.remove(symbol));
+    });
+  });
+  program.command("subscription").action(async () => {
+    await withClient(async (_, client) => {
+      print(await client.billing.getSubscription());
+    });
+  });
+  program.command("upgrade").argument("<tier>").action(async (tier) => {
+    await withClient(async (_, client) => {
+      print(await client.billing.createCheckout(tier));
+    });
+  });
+  program.command("billing").action(async () => {
+    await withClient(async (_, client) => {
+      print(await client.billing.createPortalSession());
+    });
+  });
+  const intelligence = program.command("intelligence").description("Market intelligence");
+  intelligence.command("summary").action(async () => {
+    await withClient(async (_, client) => {
+      print(await client.intelligence.getSummary());
+    });
+  });
+  intelligence.command("signals").argument("<marketId>").action(async (marketId) => {
+    await withClient(async (_, client) => {
+      print(await client.intelligence.getSignals(marketId));
+    });
+  });
+  const performance = program.command("performance").description("Performance & reflection");
+  performance.command("summary").option("--period <period>", "Time period: 7d, 30d, 90d, all").option("--category <category>", "Filter by market category").action(async (options) => {
+    await withClient(async (_, client) => {
+      print(
+        await client.performance.get({
+          ...options.period ? { period: options.period } : {},
+          ...options.category ? { category: options.category } : {}
+        })
+      );
+    });
+  });
+  performance.command("resolved").option("--cursor <cursor>", "Pagination cursor").option("--limit <limit>", "Page size (max 50)").option("--outcome <outcome>", "Filter: correct, incorrect, all").action(async (options) => {
+    await withClient(async (_, client) => {
+      print(
+        await client.performance.getResolved({
+          ...options.cursor ? { cursor: options.cursor } : {},
+          ...options.limit ? { limit: Number(options.limit) } : {},
+          ...options.outcome ? { outcome: options.outcome } : {}
+        })
+      );
+    });
+  });
+  performance.command("benchmarks").option("--period <period>", "Time period: 7d, 30d, 90d, all").action(async (options) => {
+    await withClient(async (_, client) => {
+      print(
+        await client.performance.getBenchmarks({
+          ...options.period ? { period: options.period } : {}
+        })
+      );
+    });
+  });
+  const wars = program.command("wars").description("Trading Wars");
+  wars.command("list").action(async () => {
+    await withClient(async (_, client) => {
+      print(await client.wars.list());
+    });
+  });
+  wars.command("active").action(async () => {
+    await withClient(async (_, client) => {
+      print(await client.wars.active());
+    });
+  });
+  wars.command("get").argument("<warId>").action(async (warId) => {
+    await withClient(async (_, client) => {
+      print(await client.wars.get(warId));
+    });
+  });
+  wars.command("queue").requiredOption("--tier <tier>", "Duration tier: BLITZ, STANDARD, MARATHON").action(async (options) => {
+    await withClient(async (_, client) => {
+      print(await client.wars.enterQueue({ durationTier: options.tier }));
+    });
+  });
+  wars.command("cancel-queue").action(async () => {
+    await withClient(async (_, client) => {
+      print(await client.wars.cancelQueue());
+    });
+  });
+  wars.command("queue-status").action(async () => {
+    await withClient(async (_, client) => {
+      print(await client.wars.getQueueStatus());
+    });
+  });
+  wars.command("results").argument("<warId>").action(async (warId) => {
+    await withClient(async (_, client) => {
+      print(await client.wars.results(warId));
+    });
+  });
+  wars.command("history").action(async () => {
+    await withClient(async (_, client) => {
+      print(await client.wars.history());
+    });
+  });
+  wars.command("leaderboard").action(async () => {
+    await withClient(async (_, client) => {
+      print(await client.wars.leaderboard());
+    });
+  });
+  return program;
+}
+async function saveAuth(auth, email) {
+  await saveCredentials({ token: auth.token, email });
+  process.stderr.write(
+    `${import_chalk.default.green("Saved credentials")} at ${import_chalk.default.cyan(getCredentialsPath())}
+`
+  );
+}
+async function placePredictionOrder(marketId, side, options) {
+  await withClient(async (_, client) => {
+    const response = await client.predictions.placeOrder(marketId, {
+      outcomeId: options.outcomeId,
+      side,
+      type: "LIMIT",
+      price: Number(options.price),
+      quantity: Number(options.shares)
+    });
+    print(response);
+  });
+}
+async function tradeCrypto(symbol, side, quantityRaw) {
+  await withClient(async (_, client) => {
+    const result = await client.portfolio.trade({
+      symbol,
+      side,
+      quantity: Number(quantityRaw)
+    });
+    print(result);
+  });
+}
+
+// src/index.ts
+async function main() {
+  const program = createProgram();
+  await program.parseAsync(process.argv);
+}
+main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  process.stderr.write(`${message}
+`);
+  process.exit(1);
+});
+//# sourceMappingURL=index.cjs.map