pmxtjs 2.1.2 → 2.2.0

package/pmxt/client.ts

@@ -22,6 +22,7 @@ import {
 import {
     UnifiedMarket,
     MarketOutcome,
+    MarketList,
     PriceCandle,
     OrderBook,
     OrderLevel,
@@ -159,7 +160,7 @@ function convertBalance(raw: any): Balance {
 }
 
 function convertEvent(raw: any): UnifiedEvent {
-    const markets = (raw.markets || []).map(convertMarket);
+    const markets = MarketList.from((raw.markets || []).map(convertMarket)) as MarketList;
 
     return {
         id: raw.id,

package/pmxt/models.js

@@ -0,0 +1,60 @@
+"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/models.ts

@@ -319,6 +319,65 @@ export interface CreateOrderParams {
     /** Optional fee rate (e.g., 1000 for 0.1%) */
     fee?: number;
 }
+/**
+ * A list of UnifiedMarket objects with a convenience match() method.
+ * Extends Array so all standard array operations work unchanged.
+ */
+export class MarketList extends Array<UnifiedMarket> {
+    /**
+     * 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: string, searchIn?: ('title' | 'description' | 'category' | 'tags' | 'outcomes')[]): UnifiedMarket {
+        const fields = searchIn || ['title'];
+        const lowerQuery = query.toLowerCase();
+        const matches: UnifiedMarket[] = [];
+
+        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 titlesStr = matches
+                .map((m, i) => {
+                    const truncated = m.title.length > 70 ? m.title.substring(0, 70) + '...' : m.title;
+                    return `${i + 1}. ${truncated}`;
+                })
+                .join('\n  ');
+            throw new Error(`Multiple markets matching '${query}' (${matches.length} matches):\n  ${titlesStr}\n\nPlease refine your search.`);
+        }
+        return matches[0];
+    }
+}
+
 /**
  * A grouped collection of related markets (e.g., "Who will be Fed Chair?" contains multiple candidate markets)
  */
@@ -336,7 +395,7 @@ export interface UnifiedEvent {
     slug: string;
 
     /** Related markets in this event */
-    markets: UnifiedMarket[];
+    markets: MarketList;
 
     /** Event URL */
     url: string;

package/pmxt/server-manager.js

@@ -0,0 +1,204 @@
+"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;