pmxt-core 0.0.1

package/dist/exchanges/polymarket/index.js

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolymarketExchange = void 0;
+const BaseExchange_1 = require("../../BaseExchange");
+const fetchMarkets_1 = require("./fetchMarkets");
+const searchMarkets_1 = require("./searchMarkets");
+const getMarketsBySlug_1 = require("./getMarketsBySlug");
+const fetchOHLCV_1 = require("./fetchOHLCV");
+const fetchOrderBook_1 = require("./fetchOrderBook");
+const fetchTrades_1 = require("./fetchTrades");
+const fetchPositions_1 = require("./fetchPositions");
+const auth_1 = require("./auth");
+const clob_client_1 = require("@polymarket/clob-client");
+class PolymarketExchange extends BaseExchange_1.PredictionMarketExchange {
+    constructor(credentials) {
+        super(credentials);
+        // Initialize auth if credentials are provided
+        if (credentials?.privateKey) {
+            this.auth = new auth_1.PolymarketAuth(credentials);
+        }
+    }
+    get name() {
+        return 'Polymarket';
+    }
+    async fetchMarkets(params) {
+        return (0, fetchMarkets_1.fetchMarkets)(params);
+    }
+    async searchMarkets(query, params) {
+        return (0, searchMarkets_1.searchMarkets)(query, params);
+    }
+    async getMarketsBySlug(slug) {
+        return (0, getMarketsBySlug_1.getMarketsBySlug)(slug);
+    }
+    async fetchOHLCV(id, params) {
+        return (0, fetchOHLCV_1.fetchOHLCV)(id, params);
+    }
+    async fetchOrderBook(id) {
+        return (0, fetchOrderBook_1.fetchOrderBook)(id);
+    }
+    async fetchTrades(id, params) {
+        return (0, fetchTrades_1.fetchTrades)(id, params);
+    }
+    // ----------------------------------------------------------------------------
+    // Trading Methods
+    // ----------------------------------------------------------------------------
+    /**
+     * Ensure authentication is initialized before trading operations.
+     */
+    ensureAuth() {
+        if (!this.auth) {
+            throw new Error('Trading operations require authentication. ' +
+                'Initialize PolymarketExchange with credentials: new PolymarketExchange({ privateKey: "0x..." })');
+        }
+        return this.auth;
+    }
+    async createOrder(params) {
+        const auth = this.ensureAuth();
+        const client = await auth.getClobClient();
+        // Map side to Polymarket enum
+        const side = params.side.toUpperCase() === 'BUY' ? clob_client_1.Side.BUY : clob_client_1.Side.SELL;
+        // For limit orders, price is required
+        if (params.type === 'limit' && !params.price) {
+            throw new Error('Price is required for limit orders');
+        }
+        // For market orders, use max slippage: 0.99 for BUY (willing to pay up to 99%), 0.01 for SELL (willing to accept down to 1%)
+        const price = params.price || (side === clob_client_1.Side.BUY ? 0.99 : 0.01);
+        try {
+            // We use createAndPostOrder which handles signing and posting
+            const response = await client.createAndPostOrder({
+                tokenID: params.outcomeId,
+                price: price,
+                side: side,
+                size: params.amount,
+                feeRateBps: 0,
+            }, {
+                tickSize: "0.01"
+            });
+            if (!response || !response.success) {
+                throw new Error(response?.errorMsg || 'Order placement failed');
+            }
+            return {
+                id: response.orderID,
+                marketId: params.marketId,
+                outcomeId: params.outcomeId,
+                side: params.side,
+                type: params.type,
+                price: price,
+                amount: params.amount,
+                status: 'open',
+                filled: 0,
+                remaining: params.amount,
+                timestamp: Date.now()
+            };
+        }
+        catch (error) {
+            console.error("Polymarket createOrder error:", error);
+            throw error;
+        }
+    }
+    async cancelOrder(orderId) {
+        const auth = this.ensureAuth();
+        const client = await auth.getClobClient();
+        try {
+            await client.cancelOrder({ orderID: orderId });
+            return {
+                id: orderId,
+                marketId: 'unknown',
+                outcomeId: 'unknown',
+                side: 'buy',
+                type: 'limit',
+                amount: 0,
+                status: 'cancelled',
+                filled: 0,
+                remaining: 0,
+                timestamp: Date.now()
+            };
+        }
+        catch (error) {
+            console.error("Polymarket cancelOrder error:", error);
+            throw error;
+        }
+    }
+    async fetchOrder(orderId) {
+        const auth = this.ensureAuth();
+        const client = await auth.getClobClient();
+        try {
+            const order = await client.getOrder(orderId);
+            return {
+                id: order.id,
+                marketId: order.market || 'unknown',
+                outcomeId: order.asset_id,
+                side: order.side.toLowerCase(),
+                type: order.order_type === 'GTC' ? 'limit' : 'market',
+                price: parseFloat(order.price),
+                amount: parseFloat(order.original_size),
+                status: order.status, // Needs precise mapping
+                filled: parseFloat(order.size_matched),
+                remaining: parseFloat(order.original_size) - parseFloat(order.size_matched),
+                timestamp: order.created_at * 1000
+            };
+        }
+        catch (error) {
+            console.error("Polymarket fetchOrder error:", error);
+            throw error;
+        }
+    }
+    async fetchOpenOrders(marketId) {
+        const auth = this.ensureAuth();
+        const client = await auth.getClobClient();
+        try {
+            const orders = await client.getOpenOrders({
+                market: marketId
+            });
+            return orders.map((o) => ({
+                id: o.id,
+                marketId: o.market || 'unknown',
+                outcomeId: o.asset_id,
+                side: o.side.toLowerCase(),
+                type: 'limit',
+                price: parseFloat(o.price),
+                amount: parseFloat(o.original_size),
+                status: 'open',
+                filled: parseFloat(o.size_matched),
+                remaining: parseFloat(o.size_left || (parseFloat(o.original_size) - parseFloat(o.size_matched))),
+                timestamp: o.created_at * 1000
+            }));
+        }
+        catch (error) {
+            console.error("Polymarket fetchOpenOrders error:", error);
+            return [];
+        }
+    }
+    async fetchPositions() {
+        const auth = this.ensureAuth();
+        const address = auth.getAddress();
+        return (0, fetchPositions_1.fetchPositions)(address);
+    }
+    async fetchBalance() {
+        const auth = this.ensureAuth();
+        const client = await auth.getClobClient();
+        try {
+            // 1. Fetch raw collateral balance (USDC)
+            // Polymarket relies strictly on USDC (Polygon) which has 6 decimals.
+            const USDC_DECIMALS = 6;
+            const balRes = await client.getBalanceAllowance({
+                asset_type: clob_client_1.AssetType.COLLATERAL
+            });
+            const rawBalance = parseFloat(balRes.balance);
+            const total = rawBalance / Math.pow(10, USDC_DECIMALS);
+            // 2. Fetch open orders to calculate locked funds
+            // We only care about BUY orders for USDC balance locking
+            const openOrders = await client.getOpenOrders({});
+            let locked = 0;
+            if (openOrders && Array.isArray(openOrders)) {
+                for (const order of openOrders) {
+                    if (order.side === clob_client_1.Side.BUY) {
+                        const remainingSize = parseFloat(order.original_size) - parseFloat(order.size_matched);
+                        const price = parseFloat(order.price);
+                        locked += remainingSize * price;
+                    }
+                }
+            }
+            return [{
+                    currency: 'USDC',
+                    total: total,
+                    available: total - locked, // Available for new trades
+                    locked: locked
+                }];
+        }
+        catch (error) {
+            console.error("Polymarket fetchBalance error:", error);
+            throw error;
+        }
+    }
+}
+exports.PolymarketExchange = PolymarketExchange;

package/dist/exchanges/polymarket/searchMarkets.d.ts

@@ -0,0 +1,3 @@
+import { MarketFilterParams } from '../../BaseExchange';
+import { UnifiedMarket } from '../../types';
+export declare function searchMarkets(query: string, params?: MarketFilterParams): Promise<UnifiedMarket[]>;

package/dist/exchanges/polymarket/searchMarkets.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchMarkets = searchMarkets;
+const fetchMarkets_1 = require("./fetchMarkets");
+async function searchMarkets(query, params) {
+    // Polymarket Gamma API doesn't support native search
+    // Fetch all active markets and filter client-side
+    const searchLimit = 100000; // Fetch all markets for comprehensive search
+    try {
+        // Fetch markets with a higher limit
+        const markets = await (0, fetchMarkets_1.fetchMarkets)({
+            ...params,
+            limit: searchLimit
+        });
+        // Client-side text filtering
+        const lowerQuery = query.toLowerCase();
+        const searchIn = params?.searchIn || 'title'; // Default to title-only search
+        const filtered = markets.filter(market => {
+            const titleMatch = (market.title || '').toLowerCase().includes(lowerQuery);
+            const descMatch = (market.description || '').toLowerCase().includes(lowerQuery);
+            if (searchIn === 'title')
+                return titleMatch;
+            if (searchIn === 'description')
+                return descMatch;
+            return titleMatch || descMatch; // 'both'
+        });
+        // Apply limit to filtered results
+        const limit = params?.limit || 20;
+        return filtered.slice(0, limit);
+    }
+    catch (error) {
+        console.error("Error searching Polymarket data:", error);
+        return [];
+    }
+}

package/dist/exchanges/polymarket/utils.d.ts

@@ -0,0 +1,7 @@
+import { UnifiedMarket, CandleInterval } from '../../types';
+export declare const GAMMA_API_URL = "https://gamma-api.polymarket.com/events";
+export declare const CLOB_API_URL = "https://clob.polymarket.com";
+export declare function mapMarketToUnified(event: any, market: any, options?: {
+    useQuestionAsCandidateFallback?: boolean;
+}): UnifiedMarket | null;
+export declare function mapIntervalToFidelity(interval: CandleInterval): number;

package/dist/exchanges/polymarket/utils.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLOB_API_URL = exports.GAMMA_API_URL = void 0;
+exports.mapMarketToUnified = mapMarketToUnified;
+exports.mapIntervalToFidelity = mapIntervalToFidelity;
+exports.GAMMA_API_URL = 'https://gamma-api.polymarket.com/events';
+exports.CLOB_API_URL = 'https://clob.polymarket.com';
+function mapMarketToUnified(event, market, options = {}) {
+    if (!market)
+        return null;
+    const outcomes = [];
+    // Polymarket Gamma often returns 'outcomes' and 'outcomePrices' as stringified JSON keys.
+    let outcomeLabels = [];
+    let outcomePrices = [];
+    try {
+        outcomeLabels = typeof market.outcomes === 'string' ? JSON.parse(market.outcomes) : (market.outcomes || []);
+        outcomePrices = typeof market.outcomePrices === 'string' ? JSON.parse(market.outcomePrices) : (market.outcomePrices || []);
+    }
+    catch (e) {
+        console.warn(`Error parsing outcomes for market ${market.id}:`, e);
+    }
+    // Extract CLOB token IDs for granular operations
+    let clobTokenIds = [];
+    try {
+        clobTokenIds = typeof market.clobTokenIds === 'string' ? JSON.parse(market.clobTokenIds) : (market.clobTokenIds || []);
+    }
+    catch (e) {
+        // console.warn(`Error parsing clobTokenIds for market ${market.id}`, e);
+    }
+    // Extract candidate/option name from market question for better outcome labels
+    let candidateName = null;
+    if (market.groupItemTitle) {
+        candidateName = market.groupItemTitle;
+    }
+    else if (market.question && options.useQuestionAsCandidateFallback) {
+        // Fallback or sometimes question is the candidate name in nested structures
+        // Only used if explicitly requested (e.g. for getMarketsBySlug)
+        candidateName = market.question;
+    }
+    if (outcomeLabels.length > 0) {
+        outcomeLabels.forEach((label, index) => {
+            const rawPrice = outcomePrices[index] || "0";
+            // For Yes/No markets with specific candidates, use the candidate name
+            let outcomeLabel = label;
+            if (candidateName && label.toLowerCase() === 'yes') {
+                outcomeLabel = candidateName;
+            }
+            else if (candidateName && label.toLowerCase() === 'no') {
+                outcomeLabel = `Not ${candidateName}`;
+            }
+            // 24h Price Change
+            // Polymarket API provides 'oneDayPriceChange' on the market object
+            let priceChange = 0;
+            if (index === 0 || label.toLowerCase() === 'yes' || (candidateName && label === candidateName)) {
+                priceChange = Number(market.oneDayPriceChange || 0);
+            }
+            outcomes.push({
+                id: clobTokenIds[index] || String(index), // Use CLOB Token ID as the primary ID
+                label: outcomeLabel,
+                price: parseFloat(rawPrice) || 0,
+                priceChange24h: priceChange,
+                metadata: {
+                    // clobTokenId is now the main ID, but keeping it in metadata for backward compat if needed
+                    clobTokenId: clobTokenIds[index]
+                }
+            });
+        });
+    }
+    return {
+        id: market.id,
+        title: market.question ? `${event.title} - ${market.question}` : event.title,
+        description: market.description || event.description,
+        outcomes: outcomes,
+        resolutionDate: market.endDate ? new Date(market.endDate) : (market.end_date_iso ? new Date(market.end_date_iso) : new Date()),
+        volume24h: Number(market.volume24hr || market.volume_24h || 0),
+        volume: Number(market.volume || 0),
+        liquidity: Number(market.liquidity || market.rewards?.liquidity || 0),
+        openInterest: Number(market.openInterest || market.open_interest || 0),
+        url: `https://polymarket.com/event/${event.slug}`,
+        image: event.image || market.image || `https://polymarket.com/api/og?slug=${event.slug}`,
+        category: event.category || event.tags?.[0]?.label,
+        tags: event.tags?.map((t) => t.label) || []
+    };
+}
+function mapIntervalToFidelity(interval) {
+    const mapping = {
+        '1m': 1,
+        '5m': 5,
+        '15m': 15,
+        '1h': 60,
+        '6h': 360,
+        '1d': 1440
+    };
+    return mapping[interval];
+}

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+export * from './BaseExchange';
+export * from './types';
+export * from './exchanges/polymarket';
+export * from './exchanges/kalshi';
+export * from './server/app';
+export * from './server/utils/port-manager';
+export * from './server/utils/lock-file';
+import { PolymarketExchange } from './exchanges/polymarket';
+import { KalshiExchange } from './exchanges/kalshi';
+declare const pmxt: {
+    polymarket: typeof PolymarketExchange;
+    kalshi: typeof KalshiExchange;
+    Polymarket: typeof PolymarketExchange;
+    Kalshi: typeof KalshiExchange;
+};
+export declare const polymarket: typeof PolymarketExchange;
+export declare const kalshi: typeof KalshiExchange;
+export default pmxt;

package/dist/index.js

@@ -0,0 +1,35 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kalshi = exports.polymarket = void 0;
+__exportStar(require("./BaseExchange"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./exchanges/polymarket"), exports);
+__exportStar(require("./exchanges/kalshi"), exports);
+__exportStar(require("./server/app"), exports);
+__exportStar(require("./server/utils/port-manager"), exports);
+__exportStar(require("./server/utils/lock-file"), exports);
+const polymarket_1 = require("./exchanges/polymarket");
+const kalshi_1 = require("./exchanges/kalshi");
+const pmxt = {
+    polymarket: polymarket_1.PolymarketExchange,
+    kalshi: kalshi_1.KalshiExchange,
+    Polymarket: polymarket_1.PolymarketExchange,
+    Kalshi: kalshi_1.KalshiExchange
+};
+exports.polymarket = polymarket_1.PolymarketExchange;
+exports.kalshi = kalshi_1.KalshiExchange;
+exports.default = pmxt;

package/dist/server/app.d.ts

@@ -0,0 +1 @@
+export declare function startServer(port: number): Promise<import("node:http").Server<typeof import("node:http").IncomingMessage, typeof import("node:http").ServerResponse>>;

package/dist/server/app.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startServer = startServer;
+const express_1 = __importDefault(require("express"));
+const cors_1 = __importDefault(require("cors"));
+const polymarket_1 = require("../exchanges/polymarket");
+const kalshi_1 = require("../exchanges/kalshi");
+// Singleton instances for local usage
+const exchanges = {
+    polymarket: null,
+    kalshi: null
+};
+async function startServer(port) {
+    const app = (0, express_1.default)();
+    app.use((0, cors_1.default)());
+    app.use(express_1.default.json());
+    // Health check
+    app.get('/health', (req, res) => {
+        res.json({ status: 'ok', timestamp: Date.now() });
+    });
+    // API endpoint: POST /api/:exchange/:method
+    // Body: { args: any[] }
+    app.post('/api/:exchange/:method', async (req, res, next) => {
+        try {
+            const exchangeName = req.params.exchange.toLowerCase();
+            const methodName = req.params.method;
+            const args = Array.isArray(req.body.args) ? req.body.args : [];
+            // 1. Get or Initialize Exchange
+            if (!exchanges[exchangeName]) {
+                exchanges[exchangeName] = createExchange(exchangeName);
+            }
+            const exchange = exchanges[exchangeName];
+            // 2. Validate Method
+            if (typeof exchange[methodName] !== 'function') {
+                res.status(404).json({ success: false, error: `Method '${methodName}' not found on ${exchangeName}` });
+                return;
+            }
+            // 3. Execute with direct argument spreading
+            const result = await exchange[methodName](...args);
+            res.json({ success: true, data: result });
+        }
+        catch (error) {
+            next(error);
+        }
+    });
+    // Error handler
+    app.use((error, req, res, next) => {
+        console.error('Error:', error);
+        res.status(error.status || 500).json({
+            success: false,
+            error: {
+                message: error.message || 'Internal server error',
+                // stack: process.env.NODE_ENV === 'development' ? error.stack : undefined
+            }
+        });
+    });
+    return app.listen(port);
+}
+function createExchange(name) {
+    switch (name) {
+        case 'polymarket':
+            return new polymarket_1.PolymarketExchange({
+                privateKey: process.env.POLYMARKET_PK || process.env.POLYMARKET_PRIVATE_KEY,
+                apiKey: process.env.POLYMARKET_API_KEY,
+                apiSecret: process.env.POLYMARKET_API_SECRET,
+                passphrase: process.env.POLYMARKET_PASSPHRASE
+            });
+        case 'kalshi':
+            return new kalshi_1.KalshiExchange({
+                apiKey: process.env.KALSHI_API_KEY,
+                privateKey: process.env.KALSHI_PRIVATE_KEY
+            });
+        default:
+            throw new Error(`Unknown exchange: ${name}`);
+    }
+}

package/dist/server/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import 'dotenv/config';

package/dist/server/index.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("dotenv/config");
+const app_1 = require("./app");
+const port_manager_1 = require("./utils/port-manager");
+const lock_file_1 = require("./utils/lock-file");
+async function main() {
+    const portManager = new port_manager_1.PortManager();
+    const port = await portManager.findAvailablePort(3847); // Default port
+    const lockFile = new lock_file_1.LockFile();
+    await lockFile.create(port, process.pid);
+    const server = await (0, app_1.startServer)(port);
+    console.log(`PMXT Sidecar Server running on http://localhost:${port}`);
+    console.log(`Lock file created at ${lockFile.lockPath}`);
+    // Graceful shutdown
+    const shutdown = async () => {
+        console.log('\nShutting down gracefully...');
+        server.close();
+        await lockFile.remove();
+        process.exit(0);
+    };
+    process.on('SIGTERM', shutdown);
+    process.on('SIGINT', shutdown);
+}
+main().catch((error) => {
+    console.error('Failed to start server:', error);
+    process.exit(1);
+});

package/dist/server/utils/lock-file.d.ts

@@ -0,0 +1,12 @@
+export declare class LockFile {
+    lockPath: string;
+    constructor();
+    create(port: number, pid: number): Promise<void>;
+    read(): Promise<{
+        port: number;
+        pid: number;
+        timestamp: number;
+    } | null>;
+    remove(): Promise<void>;
+    isServerRunning(): Promise<boolean>;
+}

package/dist/server/utils/lock-file.js

@@ -0,0 +1,81 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LockFile = void 0;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+class LockFile {
+    constructor() {
+        this.lockPath = path.join(os.homedir(), '.pmxt', 'server.lock');
+    }
+    async create(port, pid) {
+        await fs.mkdir(path.dirname(this.lockPath), { recursive: true });
+        await fs.writeFile(this.lockPath, JSON.stringify({ port, pid, timestamp: Date.now() }, null, 2));
+    }
+    async read() {
+        try {
+            const data = await fs.readFile(this.lockPath, 'utf-8');
+            return JSON.parse(data);
+        }
+        catch {
+            return null;
+        }
+    }
+    async remove() {
+        try {
+            await fs.unlink(this.lockPath);
+        }
+        catch {
+            // Ignore errors if file doesn't exist
+        }
+    }
+    async isServerRunning() {
+        const lock = await this.read();
+        if (!lock)
+            return false;
+        // Check if process is still alive
+        try {
+            process.kill(lock.pid, 0); // Signal 0 checks existence without killing
+            return true;
+        }
+        catch {
+            // Process doesn't exist, remove stale lock file
+            await this.remove();
+            return false;
+        }
+    }
+}
+exports.LockFile = LockFile;

package/dist/server/utils/port-manager.d.ts

@@ -0,0 +1,4 @@
+export declare class PortManager {
+    findAvailablePort(startPort?: number): Promise<number>;
+    private isPortAvailable;
+}