pmxtjs 2.8.0 → 2.9.1

package/dist/esm/pmxt/server-manager.js

@@ -104,14 +104,16 @@ export class ServerManager {
             }
         }
         // Locate pmxt-ensure-server
-        let launcherPath = 'pmxt-ensure-server'; // Default to PATH
+        const isWindows = process.platform === 'win32';
+        const launcherName = isWindows ? 'pmxt-ensure-server.js' : 'pmxt-ensure-server';
+        let launcherPath = launcherName; // Default to PATH
         try {
             // Try to resolve from pmxt-core dependency
             // For CommonJS build (which is primary), we can use require directly
             // For ESM build, this will be transpiled appropriately
             const corePackageJson = require.resolve('pmxt-core/package.json');
             const coreDir = dirname(corePackageJson);
-            const binPath = join(coreDir, 'bin', 'pmxt-ensure-server');
+            const binPath = join(coreDir, 'bin', launcherName);
             if (existsSync(binPath)) {
                 launcherPath = binPath;
             }
@@ -122,8 +124,11 @@ export class ServerManager {
         }
         // Try to start the server using pmxt-ensure-server
         const { spawn } = await import("child_process");
+        // On Windows, .js scripts must be run via node explicitly
+        const spawnCmd = launcherPath.endsWith('.js') ? 'node' : launcherPath;
+        const spawnArgs = launcherPath.endsWith('.js') ? [launcherPath] : [];
         try {
-            const proc = spawn(launcherPath, [], {
+            const proc = spawn(spawnCmd, spawnArgs, {
                 detached: true,
                 stdio: "ignore",
             });

package/dist/pmxt/server-manager.js

@@ -140,14 +140,16 @@ class ServerManager {
             }
         }
         // Locate pmxt-ensure-server
-        let launcherPath = 'pmxt-ensure-server'; // Default to PATH
+        const isWindows = process.platform === 'win32';
+        const launcherName = isWindows ? 'pmxt-ensure-server.js' : 'pmxt-ensure-server';
+        let launcherPath = launcherName; // Default to PATH
         try {
             // Try to resolve from pmxt-core dependency
             // For CommonJS build (which is primary), we can use require directly
             // For ESM build, this will be transpiled appropriately
             const corePackageJson = require.resolve('pmxt-core/package.json');
             const coreDir = (0, path_1.dirname)(corePackageJson);
-            const binPath = (0, path_1.join)(coreDir, 'bin', 'pmxt-ensure-server');
+            const binPath = (0, path_1.join)(coreDir, 'bin', launcherName);
             if ((0, fs_1.existsSync)(binPath)) {
                 launcherPath = binPath;
             }
@@ -158,8 +160,11 @@ class ServerManager {
         }
         // Try to start the server using pmxt-ensure-server
         const { spawn } = await Promise.resolve().then(() => __importStar(require("child_process")));
+        // On Windows, .js scripts must be run via node explicitly
+        const spawnCmd = launcherPath.endsWith('.js') ? 'node' : launcherPath;
+        const spawnArgs = launcherPath.endsWith('.js') ? [launcherPath] : [];
         try {
-            const proc = spawn(launcherPath, [], {
+            const proc = spawn(spawnCmd, spawnArgs, {
                 detached: true,
                 stdio: "ignore",
             });

package/generated/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmxtjs",
-  "version": "2.8.0",
+  "version": "2.9.1",
   "description": "OpenAPI client for pmxtjs",
   "author": "OpenAPI-Generator",
   "repository": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmxtjs",
-  "version": "2.8.0",
+  "version": "2.9.1",
   "description": "Unified prediction market data API - The ccxt for prediction markets",
   "author": "PMXT Contributors",
   "repository": {
@@ -42,7 +42,7 @@
     "unified"
   ],
   "dependencies": {
-    "pmxt-core": "2.8.0"
+    "pmxt-core": "2.9.1"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",

package/pmxt/server-manager.ts

@@ -130,7 +130,9 @@ export class ServerManager {
         }
 
         // Locate pmxt-ensure-server
-        let launcherPath = 'pmxt-ensure-server'; // Default to PATH
+        const isWindows = process.platform === 'win32';
+        const launcherName = isWindows ? 'pmxt-ensure-server.js' : 'pmxt-ensure-server';
+        let launcherPath = launcherName; // Default to PATH
 
         try {
             // Try to resolve from pmxt-core dependency
@@ -138,7 +140,7 @@ export class ServerManager {
             // For ESM build, this will be transpiled appropriately
             const corePackageJson = require.resolve('pmxt-core/package.json');
             const coreDir = dirname(corePackageJson);
-            const binPath = join(coreDir, 'bin', 'pmxt-ensure-server');
+            const binPath = join(coreDir, 'bin', launcherName);
 
             if (existsSync(binPath)) {
                 launcherPath = binPath;
@@ -151,8 +153,12 @@ export class ServerManager {
         // Try to start the server using pmxt-ensure-server
         const { spawn } = await import("child_process");
 
+        // On Windows, .js scripts must be run via node explicitly
+        const spawnCmd = launcherPath.endsWith('.js') ? 'node' : launcherPath;
+        const spawnArgs = launcherPath.endsWith('.js') ? [launcherPath] : [];
+
         try {
-            const proc = spawn(launcherPath, [], {
+            const proc = spawn(spawnCmd, spawnArgs, {
                 detached: true,
                 stdio: "ignore",
             });

package/pmxt/client.js

@@ -1,957 +0,0 @@
-"use strict";
-/**
- * Exchange client implementations.
- *
- * This module provides clean, TypeScript-friendly wrappers around the auto-generated
- * OpenAPI client, matching the Python API exactly.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Limitless = exports.Kalshi = exports.Polymarket = exports.Exchange = void 0;
-const index_js_1 = require("../generated/src/index.js");
-const models_js_1 = require("./models.js");
-const server_manager_js_1 = require("./server-manager.js");
-// Converter functions
-function convertMarket(raw) {
-    const outcomes = (raw.outcomes || []).map((o) => ({
-        outcomeId: o.outcomeId,
-        label: o.label,
-        price: o.price,
-        priceChange24h: o.priceChange24h,
-        metadata: o.metadata,
-    }));
-    const convertOutcome = (o) => o ? ({
-        outcomeId: o.outcomeId,
-        label: o.label,
-        price: o.price,
-        priceChange24h: o.priceChange24h,
-        metadata: o.metadata,
-    }) : undefined;
-    return {
-        marketId: raw.marketId,
-        title: raw.title,
-        outcomes,
-        volume24h: raw.volume24h || 0,
-        liquidity: raw.liquidity || 0,
-        url: raw.url,
-        description: raw.description,
-        resolutionDate: raw.resolutionDate ? new Date(raw.resolutionDate) : undefined,
-        volume: raw.volume,
-        openInterest: raw.openInterest,
-        image: raw.image,
-        category: raw.category,
-        tags: raw.tags,
-        yes: convertOutcome(raw.yes),
-        no: convertOutcome(raw.no),
-        up: convertOutcome(raw.up),
-        down: convertOutcome(raw.down),
-    };
-}
-function convertCandle(raw) {
-    return {
-        timestamp: raw.timestamp,
-        open: raw.open,
-        high: raw.high,
-        low: raw.low,
-        close: raw.close,
-        volume: raw.volume,
-    };
-}
-function convertOrderBook(raw) {
-    const bids = (raw.bids || []).map((b) => ({
-        price: b.price,
-        size: b.size,
-    }));
-    const asks = (raw.asks || []).map((a) => ({
-        price: a.price,
-        size: a.size,
-    }));
-    return {
-        bids,
-        asks,
-        timestamp: raw.timestamp,
-    };
-}
-function convertTrade(raw) {
-    return {
-        id: raw.id,
-        timestamp: raw.timestamp,
-        price: raw.price,
-        amount: raw.amount,
-        side: raw.side || "unknown",
-    };
-}
-function convertOrder(raw) {
-    return {
-        id: raw.id,
-        marketId: raw.marketId,
-        outcomeId: raw.outcomeId,
-        side: raw.side,
-        type: raw.type,
-        amount: raw.amount,
-        status: raw.status,
-        filled: raw.filled,
-        remaining: raw.remaining,
-        timestamp: raw.timestamp,
-        price: raw.price,
-        fee: raw.fee,
-    };
-}
-function convertPosition(raw) {
-    return {
-        marketId: raw.marketId,
-        outcomeId: raw.outcomeId,
-        outcomeLabel: raw.outcomeLabel,
-        size: raw.size,
-        entryPrice: raw.entryPrice,
-        currentPrice: raw.currentPrice,
-        unrealizedPnL: raw.unrealizedPnL,
-        realizedPnL: raw.realizedPnL,
-    };
-}
-function convertBalance(raw) {
-    return {
-        currency: raw.currency,
-        total: raw.total,
-        available: raw.available,
-        locked: raw.locked,
-    };
-}
-function convertEvent(raw) {
-    const markets = models_js_1.MarketList.from((raw.markets || []).map(convertMarket));
-    return {
-        id: raw.id,
-        title: raw.title,
-        description: raw.description,
-        slug: raw.slug,
-        markets,
-        url: raw.url,
-        image: raw.image,
-        category: raw.category,
-        tags: raw.tags,
-    };
-}
-/**
- * Base class for prediction market exchanges.
- *
- * This provides a unified interface for interacting with different
- * prediction market platforms (Polymarket, Kalshi, etc.).
- */
-class Exchange {
-    constructor(exchangeName, options = {}) {
-        this.exchangeName = exchangeName.toLowerCase();
-        this.apiKey = options.apiKey;
-        this.privateKey = options.privateKey;
-        this.proxyAddress = options.proxyAddress;
-        this.signatureType = options.signatureType;
-        let baseUrl = options.baseUrl || "http://localhost:3847";
-        const autoStartServer = options.autoStartServer !== false;
-        // Initialize server manager
-        this.serverManager = new server_manager_js_1.ServerManager({ baseUrl });
-        // Configure the API client with the initial base URL (will be updated if port changes)
-        this.config = new index_js_1.Configuration({ basePath: baseUrl });
-        this.api = new index_js_1.DefaultApi(this.config);
-        // Initialize the server connection asynchronously
-        this.initPromise = this.initializeServer(autoStartServer);
-    }
-    async initializeServer(autoStartServer) {
-        if (autoStartServer) {
-            try {
-                await this.serverManager.ensureServerRunning();
-                // Get the actual port the server is running on
-                // (may differ from default if default port was busy)
-                const actualPort = this.serverManager.getRunningPort();
-                const newBaseUrl = `http://localhost:${actualPort}`;
-                const accessToken = this.serverManager.getAccessToken();
-                const headers = {};
-                if (accessToken) {
-                    headers['x-pmxt-access-token'] = accessToken;
-                }
-                // Update API client with actual base URL
-                this.config = new index_js_1.Configuration({
-                    basePath: newBaseUrl,
-                    headers
-                });
-                this.api = new index_js_1.DefaultApi(this.config);
-            }
-            catch (error) {
-                throw new Error(`Failed to start PMXT server: ${error}\n\n` +
-                    `Please ensure 'pmxt-core' is installed: npm install -g pmxt-core\n` +
-                    `Or start the server manually: pmxt-server`);
-            }
-        }
-    }
-    handleResponse(response) {
-        if (!response.success) {
-            const error = response.error || {};
-            throw new Error(error.message || "Unknown error");
-        }
-        return response.data;
-    }
-    getCredentials() {
-        if (!this.apiKey && !this.privateKey) {
-            return undefined;
-        }
-        return {
-            apiKey: this.apiKey,
-            privateKey: this.privateKey,
-            funderAddress: this.proxyAddress,
-            signatureType: this.signatureType,
-        };
-    }
-    // Market Data Methods
-    /**
-     * Get active markets from the exchange.
-     *
-     * @param params - Optional filter parameters
-     * @returns List of unified markets
-     *
-     * @example
-     * ```typescript
-     * const markets = await exchange.fetchMarkets({ limit: 20, sort: "volume" });
-     * ```
-     */
-    async fetchMarkets(params) {
-        await this.initPromise;
-        try {
-            const args = [];
-            if (params) {
-                args.push(params);
-            }
-            const requestBody = {
-                args,
-                credentials: this.getCredentials()
-            };
-            const response = await this.api.fetchMarkets({
-                exchange: this.exchangeName,
-                fetchMarketsRequest: requestBody,
-            });
-            const data = this.handleResponse(response);
-            return data.map(convertMarket);
-        }
-        catch (error) {
-            throw new Error(`Failed to fetch markets: ${error}`);
-        }
-    }
-    /**
-     * Get historical price candles.
-     *
-     * @param outcomeId - Outcome ID (from market.outcomes[].outcomeId)
-     * @param params - History filter parameters
-     * @returns List of price candles
-     *
-     * @example
-     * ```typescript
-     * const markets = await exchange.fetchMarkets({ query: "Trump" });
-     * const outcomeId = markets[0].outcomes[0].outcomeId;
-     * const candles = await exchange.fetchOHLCV(outcomeId, {
-     *   resolution: "1h",
-     *   limit: 100
-     * });
-     * ```
-     */
-    async fetchOHLCV(outcomeId, params) {
-        await this.initPromise;
-        try {
-            const paramsDict = { resolution: params.resolution };
-            if (params.start) {
-                paramsDict.start = params.start.toISOString();
-            }
-            if (params.end) {
-                paramsDict.end = params.end.toISOString();
-            }
-            if (params.limit) {
-                paramsDict.limit = params.limit;
-            }
-            const requestBody = {
-                args: [outcomeId, paramsDict],
-                credentials: this.getCredentials()
-            };
-            const response = await this.api.fetchOHLCV({
-                exchange: this.exchangeName,
-                fetchOHLCVRequest: requestBody,
-            });
-            const data = this.handleResponse(response);
-            return data.map(convertCandle);
-        }
-        catch (error) {
-            throw new Error(`Failed to fetch OHLCV: ${error}`);
-        }
-    }
-    /**
-     * Get current order book for an outcome.
-     *
-     * @param outcomeId - Outcome ID
-     * @returns Current order book
-     *
-     * @example
-     * ```typescript
-     * const orderBook = await exchange.fetchOrderBook(outcomeId);
-     * console.log(`Best bid: ${orderBook.bids[0].price}`);
-     * console.log(`Best ask: ${orderBook.asks[0].price}`);
-     * ```
-     */
-    async fetchOrderBook(outcomeId) {
-        await this.initPromise;
-        try {
-            const requestBody = {
-                args: [outcomeId],
-                credentials: this.getCredentials()
-            };
-            const response = await this.api.fetchOrderBook({
-                exchange: this.exchangeName,
-                fetchOrderBookRequest: requestBody,
-            });
-            const data = this.handleResponse(response);
-            return convertOrderBook(data);
-        }
-        catch (error) {
-            throw new Error(`Failed to fetch order book: ${error}`);
-        }
-    }
-    /**
-     * Get trade history for an outcome.
-     *
-     * Note: Polymarket requires API key.
-     *
-     * @param outcomeId - Outcome ID
-     * @param params - History filter parameters
-     * @returns List of trades
-     */
-    async fetchTrades(outcomeId, params) {
-        await this.initPromise;
-        try {
-            const paramsDict = { resolution: params.resolution };
-            if (params.limit) {
-                paramsDict.limit = params.limit;
-            }
-            const requestBody = {
-                args: [outcomeId, paramsDict],
-                credentials: this.getCredentials()
-            };
-            const response = await this.api.fetchTrades({
-                exchange: this.exchangeName,
-                fetchTradesRequest: requestBody,
-            });
-            const data = this.handleResponse(response);
-            return data.map(convertTrade);
-        }
-        catch (error) {
-            throw new Error(`Failed to fetch trades: ${error}`);
-        }
-    }
-    // WebSocket Streaming Methods
-    /**
-     * Watch real-time order book updates via WebSocket.
-     *
-     * Returns a promise that resolves with the next order book update.
-     * Call repeatedly in a loop to stream updates (CCXT Pro pattern).
-     *
-     * @param outcomeId - Outcome ID to watch
-     * @param limit - Optional depth limit for order book
-     * @returns Next order book update
-     *
-     * @example
-     * ```typescript
-     * // Stream order book updates
-     * while (true) {
-     *   const orderBook = await exchange.watchOrderBook(outcomeId);
-     *   console.log(`Best bid: ${orderBook.bids[0].price}`);
-     *   console.log(`Best ask: ${orderBook.asks[0].price}`);
-     * }
-     * ```
-     */
-    async watchOrderBook(outcomeId, limit) {
-        await this.initPromise;
-        try {
-            const args = [outcomeId];
-            if (limit !== undefined) {
-                args.push(limit);
-            }
-            const requestBody = {
-                args,
-                credentials: this.getCredentials()
-            };
-            const response = await this.api.watchOrderBook({
-                exchange: this.exchangeName,
-                watchOrderBookRequest: requestBody,
-            });
-            const data = this.handleResponse(response);
-            return convertOrderBook(data);
-        }
-        catch (error) {
-            throw new Error(`Failed to watch order book: ${error}`);
-        }
-    }
-    /**
-     * Watch real-time trade updates via WebSocket.
-     *
-     * Returns a promise that resolves with the next trade(s).
-     * Call repeatedly in a loop to stream updates (CCXT Pro pattern).
-     *
-     * @param outcomeId - Outcome ID to watch
-     * @param since - Optional timestamp to filter trades from
-     * @param limit - Optional limit for number of trades
-     * @returns Next trade update(s)
-     *
-     * @example
-     * ```typescript
-     * // Stream trade updates
-     * while (true) {
-     *   const trades = await exchange.watchTrades(outcomeId);
-     *   for (const trade of trades) {
-     *     console.log(`Trade: ${trade.price} @ ${trade.amount}`);
-     *   }
-     * }
-     * ```
-     */
-    async watchTrades(outcomeId, since, limit) {
-        await this.initPromise;
-        try {
-            const args = [outcomeId];
-            if (since !== undefined) {
-                args.push(since);
-            }
-            if (limit !== undefined) {
-                args.push(limit);
-            }
-            const requestBody = {
-                args,
-                credentials: this.getCredentials()
-            };
-            const response = await this.api.watchTrades({
-                exchange: this.exchangeName,
-                watchTradesRequest: requestBody,
-            });
-            const data = this.handleResponse(response);
-            return data.map(convertTrade);
-        }
-        catch (error) {
-            throw new Error(`Failed to watch trades: ${error}`);
-        }
-    }
-    // Trading Methods (require authentication)
-    /**
-     * Create a new order.
-     *
-     * @param params - Order parameters
-     * @returns Created order
-     *
-     * @example
-     * ```typescript
-     * const order = await exchange.createOrder({
-     *   marketId: "663583",
-     *   outcomeId: "10991849...",
-     *   side: "buy",
-     *   type: "limit",
-     *   amount: 10,
-     *   price: 0.55
-     * });
-     * ```
-     */
-    async createOrder(params) {
-        await this.initPromise;
-        try {
-            const paramsDict = {
-                marketId: params.marketId,
-                outcomeId: params.outcomeId,
-                side: params.side,
-                type: params.type,
-                amount: params.amount,
-            };
-            if (params.price !== undefined) {
-                paramsDict.price = params.price;
-            }
-            if (params.fee !== undefined) {
-                paramsDict.fee = params.fee;
-            }
-            const requestBody = {
-                args: [paramsDict],
-                credentials: this.getCredentials()
-            };
-            const response = await this.api.createOrder({
-                exchange: this.exchangeName,
-                createOrderRequest: requestBody,
-            });
-            const data = this.handleResponse(response);
-            return convertOrder(data);
-        }
-        catch (error) {
-            throw new Error(`Failed to create order: ${error}`);
-        }
-    }
-    /**
-     * Cancel an open order.
-     *
-     * @param orderId - Order ID to cancel
-     * @returns Cancelled order
-     */
-    async cancelOrder(orderId) {
-        await this.initPromise;
-        try {
-            const requestBody = {
-                args: [orderId],
-                credentials: this.getCredentials()
-            };
-            const response = await this.api.cancelOrder({
-                exchange: this.exchangeName,
-                cancelOrderRequest: requestBody,
-            });
-            const data = this.handleResponse(response);
-            return convertOrder(data);
-        }
-        catch (error) {
-            throw new Error(`Failed to cancel order: ${error}`);
-        }
-    }
-    /**
-     * Get details of a specific order.
-     *
-     * @param orderId - Order ID
-     * @returns Order details
-     */
-    async fetchOrder(orderId) {
-        await this.initPromise;
-        try {
-            const requestBody = {
-                args: [orderId],
-                credentials: this.getCredentials()
-            };
-            const response = await this.api.fetchOrder({
-                exchange: this.exchangeName,
-                cancelOrderRequest: requestBody,
-            });
-            const data = this.handleResponse(response);
-            return convertOrder(data);
-        }
-        catch (error) {
-            throw new Error(`Failed to fetch order: ${error}`);
-        }
-    }
-    /**
-     * Get all open orders, optionally filtered by market.
-     *
-     * @param marketId - Optional market ID to filter by
-     * @returns List of open orders
-     */
-    async fetchOpenOrders(marketId) {
-        await this.initPromise;
-        try {
-            const args = [];
-            if (marketId) {
-                args.push(marketId);
-            }
-            const requestBody = {
-                args,
-                credentials: this.getCredentials()
-            };
-            const response = await this.api.fetchOpenOrders({
-                exchange: this.exchangeName,
-                fetchOpenOrdersRequest: requestBody,
-            });
-            const data = this.handleResponse(response);
-            return data.map(convertOrder);
-        }
-        catch (error) {
-            throw new Error(`Failed to fetch open orders: ${error}`);
-        }
-    }
-    // Account Methods
-    /**
-     * Get current positions across all markets.
-     *
-     * @returns List of positions
-     */
-    async fetchPositions() {
-        await this.initPromise;
-        try {
-            const requestBody = {
-                args: [],
-                credentials: this.getCredentials()
-            };
-            const response = await this.api.fetchPositions({
-                exchange: this.exchangeName,
-                fetchPositionsRequest: requestBody,
-            });
-            const data = this.handleResponse(response);
-            return data.map(convertPosition);
-        }
-        catch (error) {
-            throw new Error(`Failed to fetch positions: ${error}`);
-        }
-    }
-    /**
-     * Get account balance.
-     *
-     * @returns List of balances (by currency)
-     */
-    async fetchBalance() {
-        await this.initPromise;
-        try {
-            const requestBody = {
-                args: [],
-                credentials: this.getCredentials()
-            };
-            const response = await this.api.fetchBalance({
-                exchange: this.exchangeName,
-                fetchPositionsRequest: requestBody,
-            });
-            const data = this.handleResponse(response);
-            return data.map(convertBalance);
-        }
-        catch (error) {
-            throw new Error(`Failed to fetch balance: ${error}`);
-        }
-    }
-    /**
-     * Calculate the average execution price for a given amount by walking the order book.
-     * Uses the sidecar server for calculation to ensure consistency.
-     *
-     * @param orderBook - The current order book
-     * @param side - 'buy' or 'sell'
-     * @param amount - The amount to execute
-     * @returns The volume-weighted average price, or 0 if insufficient liquidity
-     */
-    async getExecutionPrice(orderBook, side, amount) {
-        const result = await this.getExecutionPriceDetailed(orderBook, side, amount);
-        return result.fullyFilled ? result.price : 0;
-    }
-    /**
-     * Calculate detailed execution price information.
-     * Uses the sidecar server for calculation to ensure consistency.
-     *
-     * @param orderBook - The current order book
-     * @param side - 'buy' or 'sell'
-     * @param amount - The amount to execute
-     * @returns Detailed execution result
-     */
-    async getExecutionPriceDetailed(orderBook, side, amount) {
-        await this.initPromise;
-        try {
-            const body = {
-                args: [orderBook, side, amount]
-            };
-            const credentials = this.getCredentials();
-            if (credentials) {
-                body.credentials = credentials;
-            }
-            const url = `${this.config.basePath}/api/${this.exchangeName}/getExecutionPriceDetailed`;
-            const response = await fetch(url, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    ...this.config.headers
-                },
-                body: JSON.stringify(body)
-            });
-            if (!response.ok) {
-                const error = await response.json().catch(() => ({}));
-                throw new Error(error.error?.message || response.statusText);
-            }
-            const json = await response.json();
-            return this.handleResponse(json);
-        }
-        catch (error) {
-            throw new Error(`Failed to get execution price: ${error}`);
-        }
-    }
-    // ----------------------------------------------------------------------------
-    // Filtering Methods
-    // ----------------------------------------------------------------------------
-    /**
-     * Filter markets based on criteria or custom function.
-     *
-     * @param markets - Array of markets to filter
-     * @param criteria - Filter criteria object, string (simple text search), or predicate function
-     * @returns Filtered array of markets
-     *
-     * @example Simple text search
-     * api.filterMarkets(markets, 'Trump')
-     *
-     * @example Advanced filtering
-     * api.filterMarkets(markets, {
-     *   text: 'Trump',
-     *   searchIn: ['title', 'tags'],
-     *   volume24h: { min: 10000 },
-     *   category: 'Politics',
-     *   price: { outcome: 'yes', max: 0.5 }
-     * })
-     *
-     * @example Custom predicate
-     * api.filterMarkets(markets, m => m.liquidity > 5000 && m.yes?.price < 0.3)
-     */
-    filterMarkets(markets, criteria) {
-        // Handle predicate function
-        if (typeof criteria === 'function') {
-            return markets.filter(criteria);
-        }
-        // Handle simple string search
-        if (typeof criteria === 'string') {
-            const lowerQuery = criteria.toLowerCase();
-            return markets.filter(m => m.title.toLowerCase().includes(lowerQuery));
-        }
-        // Handle criteria object
-        return markets.filter(market => {
-            // Text search
-            if (criteria.text) {
-                const lowerQuery = criteria.text.toLowerCase();
-                const searchIn = criteria.searchIn || ['title'];
-                let textMatch = false;
-                for (const field of searchIn) {
-                    if (field === 'title' && market.title?.toLowerCase().includes(lowerQuery)) {
-                        textMatch = true;
-                        break;
-                    }
-                    if (field === 'description' && market.description?.toLowerCase().includes(lowerQuery)) {
-                        textMatch = true;
-                        break;
-                    }
-                    if (field === 'category' && market.category?.toLowerCase().includes(lowerQuery)) {
-                        textMatch = true;
-                        break;
-                    }
-                    if (field === 'tags' && market.tags?.some(tag => tag.toLowerCase().includes(lowerQuery))) {
-                        textMatch = true;
-                        break;
-                    }
-                    if (field === 'outcomes' && market.outcomes?.some(o => o.label.toLowerCase().includes(lowerQuery))) {
-                        textMatch = true;
-                        break;
-                    }
-                }
-                if (!textMatch)
-                    return false;
-            }
-            // Category filter
-            if (criteria.category && market.category !== criteria.category) {
-                return false;
-            }
-            // Tags filter (match ANY of the provided tags)
-            if (criteria.tags && criteria.tags.length > 0) {
-                const hasMatchingTag = criteria.tags.some(tag => market.tags?.some(marketTag => marketTag.toLowerCase() === tag.toLowerCase()));
-                if (!hasMatchingTag)
-                    return false;
-            }
-            // Volume24h filter
-            if (criteria.volume24h) {
-                if (criteria.volume24h.min !== undefined && market.volume24h < criteria.volume24h.min) {
-                    return false;
-                }
-                if (criteria.volume24h.max !== undefined && market.volume24h > criteria.volume24h.max) {
-                    return false;
-                }
-            }
-            // Volume filter
-            if (criteria.volume) {
-                if (criteria.volume.min !== undefined && (market.volume || 0) < criteria.volume.min) {
-                    return false;
-                }
-                if (criteria.volume.max !== undefined && (market.volume || 0) > criteria.volume.max) {
-                    return false;
-                }
-            }
-            // Liquidity filter
-            if (criteria.liquidity) {
-                if (criteria.liquidity.min !== undefined && market.liquidity < criteria.liquidity.min) {
-                    return false;
-                }
-                if (criteria.liquidity.max !== undefined && market.liquidity > criteria.liquidity.max) {
-                    return false;
-                }
-            }
-            // OpenInterest filter
-            if (criteria.openInterest) {
-                if (criteria.openInterest.min !== undefined && (market.openInterest || 0) < criteria.openInterest.min) {
-                    return false;
-                }
-                if (criteria.openInterest.max !== undefined && (market.openInterest || 0) > criteria.openInterest.max) {
-                    return false;
-                }
-            }
-            // ResolutionDate filter
-            if (criteria.resolutionDate && market.resolutionDate) {
-                const resDate = market.resolutionDate;
-                if (criteria.resolutionDate.before && resDate >= criteria.resolutionDate.before) {
-                    return false;
-                }
-                if (criteria.resolutionDate.after && resDate <= criteria.resolutionDate.after) {
-                    return false;
-                }
-            }
-            // Price filter (for binary markets)
-            if (criteria.price) {
-                const outcome = market[criteria.price.outcome];
-                if (!outcome)
-                    return false;
-                if (criteria.price.min !== undefined && outcome.price < criteria.price.min) {
-                    return false;
-                }
-                if (criteria.price.max !== undefined && outcome.price > criteria.price.max) {
-                    return false;
-                }
-            }
-            // Price change filter
-            if (criteria.priceChange24h) {
-                const outcome = market[criteria.priceChange24h.outcome];
-                if (!outcome || outcome.priceChange24h === undefined)
-                    return false;
-                if (criteria.priceChange24h.min !== undefined && outcome.priceChange24h < criteria.priceChange24h.min) {
-                    return false;
-                }
-                if (criteria.priceChange24h.max !== undefined && outcome.priceChange24h > criteria.priceChange24h.max) {
-                    return false;
-                }
-            }
-            return true;
-        });
-    }
-    /**
-     * Filter events based on criteria or custom function.
-     *
-     * @param events - Array of events to filter
-     * @param criteria - Filter criteria object, string (simple text search), or predicate function
-     * @returns Filtered array of events
-     *
-     * @example Simple text search
-     * api.filterEvents(events, 'Trump')
-     *
-     * @example Advanced filtering
-     * api.filterEvents(events, {
-     *   text: 'Election',
-     *   searchIn: ['title', 'tags'],
-     *   category: 'Politics',
-     *   marketCount: { min: 5 }
-     * })
-     *
-     * @example Custom predicate
-     * api.filterEvents(events, e => e.markets.length > 10)
-     */
-    filterEvents(events, criteria) {
-        // Handle predicate function
-        if (typeof criteria === 'function') {
-            return events.filter(criteria);
-        }
-        // Handle simple string search
-        if (typeof criteria === 'string') {
-            const lowerQuery = criteria.toLowerCase();
-            return events.filter(e => e.title.toLowerCase().includes(lowerQuery));
-        }
-        // Handle criteria object
-        return events.filter(event => {
-            // Text search
-            if (criteria.text) {
-                const lowerQuery = criteria.text.toLowerCase();
-                const searchIn = criteria.searchIn || ['title'];
-                let textMatch = false;
-                for (const field of searchIn) {
-                    if (field === 'title' && event.title?.toLowerCase().includes(lowerQuery)) {
-                        textMatch = true;
-                        break;
-                    }
-                    if (field === 'description' && event.description?.toLowerCase().includes(lowerQuery)) {
-                        textMatch = true;
-                        break;
-                    }
-                    if (field === 'category' && event.category?.toLowerCase().includes(lowerQuery)) {
-                        textMatch = true;
-                        break;
-                    }
-                    if (field === 'tags' && event.tags?.some(tag => tag.toLowerCase().includes(lowerQuery))) {
-                        textMatch = true;
-                        break;
-                    }
-                }
-                if (!textMatch)
-                    return false;
-            }
-            // Category filter
-            if (criteria.category && event.category !== criteria.category) {
-                return false;
-            }
-            // Tags filter (match ANY of the provided tags)
-            if (criteria.tags && criteria.tags.length > 0) {
-                const hasMatchingTag = criteria.tags.some(tag => event.tags?.some(eventTag => eventTag.toLowerCase() === tag.toLowerCase()));
-                if (!hasMatchingTag)
-                    return false;
-            }
-            // Market count filter
-            if (criteria.marketCount) {
-                const count = event.markets.length;
-                if (criteria.marketCount.min !== undefined && count < criteria.marketCount.min) {
-                    return false;
-                }
-                if (criteria.marketCount.max !== undefined && count > criteria.marketCount.max) {
-                    return false;
-                }
-            }
-            // Total volume filter
-            if (criteria.totalVolume) {
-                const totalVolume = event.markets.reduce((sum, m) => sum + m.volume24h, 0);
-                if (criteria.totalVolume.min !== undefined && totalVolume < criteria.totalVolume.min) {
-                    return false;
-                }
-                if (criteria.totalVolume.max !== undefined && totalVolume > criteria.totalVolume.max) {
-                    return false;
-                }
-            }
-            return true;
-        });
-    }
-}
-exports.Exchange = Exchange;
-class Polymarket extends Exchange {
-    constructor(options = {}) {
-        // Default to gnosis-safe signature type
-        const polyOptions = {
-            signatureType: 'gnosis-safe',
-            ...options
-        };
-        super("polymarket", polyOptions);
-    }
-}
-exports.Polymarket = Polymarket;
-/**
- * Kalshi exchange client.
- *
- * @example
- * ```typescript
- * // Public data (no auth)
- * const kalshi = new Kalshi();
- * const markets = await kalshi.fetchMarkets({ query: "Fed rates" });
- *
- * // Trading (requires auth)
- * const kalshi = new Kalshi({
- *   apiKey: process.env.KALSHI_API_KEY,
- *   privateKey: process.env.KALSHI_PRIVATE_KEY
- * });
- * const balance = await kalshi.fetchBalance();
- * ```
- */
-class Kalshi extends Exchange {
-    constructor(options = {}) {
-        super("kalshi", options);
-    }
-}
-exports.Kalshi = Kalshi;
-/**
- * Limitless exchange client.
- *
- * @example
- * ```typescript
- * // Public data (no auth)
- * const limitless = new Limitless();
- * const markets = await limitless.fetchMarkets({ query: "Trump" });
- *
- * // Trading (requires auth)
- * const limitless = new Limitless({
- *   apiKey: process.env.LIMITLESS_API_KEY,
- *   privateKey: process.env.LIMITLESS_PRIVATE_KEY
- * });
- * const balance = await limitless.fetchBalance();
- * ```
- */
-class Limitless extends Exchange {
-    constructor(options = {}) {
-        super("limitless", options);
-    }
-}
-exports.Limitless = Limitless;

package/pmxt/models.js

@@ -1,60 +0,0 @@
-"use strict";
-/**
- * Data models for PMXT TypeScript SDK.
- *
- * These are clean TypeScript interfaces that provide a user-friendly API.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MarketList = void 0;
-/**
- * A list of UnifiedMarket objects with a convenience match() method.
- * Extends Array so all standard array operations work unchanged.
- */
-class MarketList extends Array {
-    /**
-     * Find a single market by case-insensitive substring match.
-     *
-     * @param query - Substring to search for
-     * @param searchIn - Fields to search in (default: ['title'])
-     * @returns The matching UnifiedMarket
-     * @throws Error if zero or multiple markets match
-     */
-    match(query, searchIn) {
-        const fields = searchIn || ['title'];
-        const lowerQuery = query.toLowerCase();
-        const matches = [];
-        for (const m of this) {
-            for (const field of fields) {
-                if (field === 'title' && m.title?.toLowerCase().includes(lowerQuery)) {
-                    matches.push(m);
-                    break;
-                }
-                if (field === 'description' && m.description?.toLowerCase().includes(lowerQuery)) {
-                    matches.push(m);
-                    break;
-                }
-                if (field === 'category' && m.category?.toLowerCase().includes(lowerQuery)) {
-                    matches.push(m);
-                    break;
-                }
-                if (field === 'tags' && m.tags?.some(t => t.toLowerCase().includes(lowerQuery))) {
-                    matches.push(m);
-                    break;
-                }
-                if (field === 'outcomes' && m.outcomes?.some(o => o.label.toLowerCase().includes(lowerQuery))) {
-                    matches.push(m);
-                    break;
-                }
-            }
-        }
-        if (matches.length === 0) {
-            throw new Error(`No markets matching '${query}'`);
-        }
-        if (matches.length > 1) {
-            const titles = matches.map(m => m.title);
-            throw new Error(`Multiple markets matching '${query}': ${JSON.stringify(titles)}`);
-        }
-        return matches[0];
-    }
-}
-exports.MarketList = MarketList;

package/pmxt/server-manager.js

@@ -1,204 +0,0 @@
-"use strict";
-/**
- * Server manager for PMXT TypeScript SDK.
- *
- * Handles automatic server startup and health checks.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ServerManager = void 0;
-const index_js_1 = require("../generated/src/index.js");
-const fs_1 = require("fs");
-const os_1 = require("os");
-const path_1 = require("path");
-class ServerManager {
-    constructor(options = {}) {
-        this.baseUrl = options.baseUrl || `http://localhost:${ServerManager.DEFAULT_PORT}`;
-        this.maxRetries = options.maxRetries || 30;
-        this.retryDelayMs = options.retryDelayMs || 1000;
-        this.lockPath = (0, path_1.join)((0, os_1.homedir)(), '.pmxt', 'server.lock');
-        const config = new index_js_1.Configuration({ basePath: this.baseUrl });
-        this.api = new index_js_1.DefaultApi(config);
-    }
-    /**
-     * Read server information from lock file.
-     */
-    getServerInfo() {
-        try {
-            if (!(0, fs_1.existsSync)(this.lockPath)) {
-                return null;
-            }
-            const content = (0, fs_1.readFileSync)(this.lockPath, 'utf-8');
-            return JSON.parse(content);
-        }
-        catch {
-            return null;
-        }
-    }
-    /**
-     * Get the actual port the server is running on.
-     *
-     * This reads the lock file to determine the actual port,
-     * which may differ from the default if the default port was busy.
-     */
-    getRunningPort() {
-        const info = this.getServerInfo();
-        return info?.port || ServerManager.DEFAULT_PORT;
-    }
-    /**
-     * Get the access token from the lock file.
-     */
-    getAccessToken() {
-        const info = this.getServerInfo();
-        return info?.accessToken;
-    }
-    /**
-     * Check if the server is running.
-     */
-    async isServerRunning() {
-        // Read lock file to get current port
-        const port = this.getRunningPort();
-        try {
-            // Use native fetch to check health on the actual running port
-            // This avoids issues where this.api is configured with the wrong port
-            const response = await fetch(`http://localhost:${port}/health`);
-            if (response.ok) {
-                const data = await response.json();
-                return data.status === "ok";
-            }
-            return false;
-        }
-        catch (error) {
-            return false;
-        }
-    }
-    /**
-     * Wait for the server to be ready.
-     */
-    async waitForServer() {
-        for (let i = 0; i < this.maxRetries; i++) {
-            if (await this.isServerRunning()) {
-                return;
-            }
-            await new Promise((resolve) => setTimeout(resolve, this.retryDelayMs));
-        }
-        throw new Error(`Server did not start within ${(this.maxRetries * this.retryDelayMs) / 1000}s`);
-    }
-    /**
-     * Ensure the server is running, starting it if necessary.
-     */
-    async ensureServerRunning() {
-        // Check for force restart
-        if (process.env.PMXT_ALWAYS_RESTART === '1') {
-            await this.killOldServer();
-        }
-        // Check if already running and version matches
-        if (await this.isServerRunning()) {
-            if (await this.isVersionMismatch()) {
-                await this.killOldServer();
-            }
-            else {
-                return;
-            }
-        }
-        // Locate pmxt-ensure-server
-        let launcherPath = 'pmxt-ensure-server'; // Default to PATH
-        try {
-            // Try to resolve from pmxt-core dependency
-            // For CommonJS build (which is primary), we can use require directly
-            // For ESM build, this will be transpiled appropriately
-            const corePackageJson = require.resolve('pmxt-core/package.json');
-            const coreDir = (0, path_1.dirname)(corePackageJson);
-            const binPath = (0, path_1.join)(coreDir, 'bin', 'pmxt-ensure-server');
-            if ((0, fs_1.existsSync)(binPath)) {
-                launcherPath = binPath;
-            }
-        }
-        catch (error) {
-            // If resolution fails, fall back to PATH
-            // This could happen in dev environments where pmxt-core is globally installed
-        }
-        // Try to start the server using pmxt-ensure-server
-        const { spawn } = await Promise.resolve().then(() => require("child_process"));
-        try {
-            const proc = spawn(launcherPath, [], {
-                detached: true,
-                stdio: "ignore",
-            });
-            proc.unref();
-            // Wait for server to be ready
-            await this.waitForServer();
-        }
-        catch (error) {
-            throw new Error(`Failed to start PMXT server: ${error}\n\n` +
-                `Please ensure 'pmxt-core' is installed: npm install -g pmxt-core\n` +
-                `Or start the server manually: pmxt-server`);
-        }
-    }
-    async isVersionMismatch() {
-        const info = this.getServerInfo();
-        if (!info || !info.version) {
-            return true; // Old server without version
-        }
-        try {
-            // 1. Try to find package.json relative to the installed location (Production)
-            let corePackageJsonPath;
-            try {
-                corePackageJsonPath = require.resolve('pmxt-core/package.json');
-            }
-            catch {
-                // 2. Try dev path (Monorepo)
-                const devPath = (0, path_1.join)((0, path_1.dirname)(__dirname), '../../core/package.json');
-                if ((0, fs_1.existsSync)(devPath)) {
-                    corePackageJsonPath = devPath;
-                }
-            }
-            if (corePackageJsonPath && (0, fs_1.existsSync)(corePackageJsonPath)) {
-                const content = (0, fs_1.readFileSync)(corePackageJsonPath, 'utf-8');
-                const pkg = JSON.parse(content);
-                // Check if running version starts with package version
-                // (Server version might have extra hash in dev mode)
-                if (pkg.version && !info.version.startsWith(pkg.version)) {
-                    return true;
-                }
-            }
-        }
-        catch {
-            // Ignore errors
-        }
-        return false;
-    }
-    /**
-     * Stop the currently running server.
-     */
-    async stop() {
-        await this.killOldServer();
-    }
-    /**
-     * Restart the server.
-     */
-    async restart() {
-        await this.stop();
-        await this.ensureServerRunning();
-    }
-    async killOldServer() {
-        const info = this.getServerInfo();
-        if (info && info.pid) {
-            try {
-                process.kill(info.pid, 'SIGTERM');
-                // Brief wait
-                await new Promise(resolve => setTimeout(resolve, 500));
-            }
-            catch {
-                // Ignore
-            }
-        }
-        // Remove lock file (best effort)
-        try {
-            const { unlinkSync } = await Promise.resolve().then(() => require('fs'));
-            unlinkSync(this.lockPath);
-        }
-        catch { }
-    }
-}
-exports.ServerManager = ServerManager;
-ServerManager.DEFAULT_PORT = 3847;