pmxtjs 2.25.2 → 2.26.0

package/dist/esm/pmxt/client.js

@@ -1619,3 +1619,73 @@ export class Baozi extends Exchange {
         super("baozi", options);
     }
 }
+/**
+ * Opinion exchange client.
+ *
+ * Polygon-based CLOB exchange. Public catalog endpoints work without
+ * credentials; trading requires `apiKey` (proxy address) and `privateKey`.
+ *
+ * @example
+ * ```typescript
+ * const opinion = new Opinion();
+ * const events = await opinion.fetchEvents();
+ * ```
+ */
+export class Opinion extends Exchange {
+    constructor(options = {}) {
+        super("opinion", options);
+    }
+}
+/**
+ * Metaculus exchange client.
+ *
+ * Forecasting platform. Public read-only access works without credentials;
+ * authenticated calls accept a bearer token via `apiKey`.
+ *
+ * @example
+ * ```typescript
+ * const metaculus = new Metaculus();
+ * const events = await metaculus.fetchEvents();
+ * ```
+ */
+export class Metaculus extends Exchange {
+    constructor(options = {}) {
+        super("metaculus", options);
+    }
+}
+/**
+ * Smarkets exchange client.
+ *
+ * UK-based betting exchange. Public catalog endpoints work without
+ * credentials; trading requires Smarkets account email (`apiKey`) and
+ * password (`privateKey`).
+ *
+ * @example
+ * ```typescript
+ * const smarkets = new Smarkets();
+ * const events = await smarkets.fetchEvents();
+ * ```
+ */
+export class Smarkets extends Exchange {
+    constructor(options = {}) {
+        super("smarkets", options);
+    }
+}
+/**
+ * Polymarket US exchange client.
+ *
+ * US-regulated Polymarket venue. Public catalog endpoints work without
+ * credentials; trading requires `apiKey` (keyId) and `privateKey`
+ * (secretKey) issued by Polymarket US.
+ *
+ * @example
+ * ```typescript
+ * const polyUs = new PolymarketUS();
+ * const events = await polyUs.fetchEvents();
+ * ```
+ */
+export class PolymarketUS extends Exchange {
+    constructor(options = {}) {
+        super("polymarket_us", options);
+    }
+}

package/dist/esm/pmxt/server-manager.d.ts

@@ -15,6 +15,7 @@ export declare class ServerManager {
     private api;
     private lockPath;
     private static readonly DEFAULT_PORT;
+    private static ensurePromise;
     constructor(options?: ServerManagerOptions);
     /**
      * Read server information from lock file.
@@ -43,8 +44,13 @@ export declare class ServerManager {
     private waitForServer;
     /**
      * Ensure the server is running, starting it if necessary.
+     *
+     * Concurrent calls across all ServerManager instances in the process
+     * are coalesced onto a single in-flight promise. See the comment on
+     * `ServerManager.ensurePromise` for why this matters.
      */
     ensureServerRunning(): Promise<void>;
+    private doEnsureServerRunning;
     private isVersionMismatch;
     /**
      * Stop the currently running server.
@@ -54,5 +60,36 @@ export declare class ServerManager {
      * Restart the server.
      */
     restart(): Promise<void>;
+    /**
+     * Start the server if it is not already running.
+     *
+     * Idempotent: if the server is already running and healthy this returns
+     * immediately without restarting.
+     */
+    start(): Promise<void>;
+    /**
+     * Get a structured snapshot of the sidecar server state.
+     *
+     * Returns a fresh object on every call (no shared mutable state).
+     */
+    status(): Promise<{
+        running: boolean;
+        pid: number | null;
+        port: number | null;
+        version: string | null;
+        uptimeSeconds: number | null;
+        lockFile: string;
+    }>;
+    /**
+     * Check whether the server's /health endpoint is currently responsive.
+     */
+    health(): Promise<boolean>;
+    /**
+     * Return the last `n` lines from the sidecar server log file.
+     *
+     * The launcher writes server stdout/stderr to ~/.pmxt/server.log.
+     * Returns an empty array if no log file is present.
+     */
+    logs(n?: number): string[];
     private killOldServer;
 }

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

@@ -14,6 +14,28 @@ export class ServerManager {
     api;
     lockPath;
     static DEFAULT_PORT = 3847;
+    // Process-wide coalescing of concurrent ensureServerRunning() calls.
+    //
+    // Each `Exchange` instance constructs its own ServerManager and each one
+    // kicks off ensureServerRunning() from its constructor. Without
+    // coalescing, N Exchange instances created in parallel all see "no
+    // server running", all spawn their own sidecar via pmxt-ensure-server,
+    // and the lock file ends up pointing at whichever spawn wrote last. Each
+    // Exchange instance has already captured its own basePath at
+    // construction time, so most of them end up talking to a sidecar whose
+    // access token does NOT match the token they later read from the lock
+    // file — every request returns 401 Unauthorized.
+    //
+    // The fix is process-wide: when a ensureServerRunning call is in
+    // flight, all subsequent callers await the same promise. After the
+    // in-flight call settles (success OR failure) the cache is cleared so
+    // later callers can re-check the sidecar state (e.g. if it was killed
+    // by the user between ticks).
+    //
+    // This is static on purpose — all ServerManager instances in the
+    // process share the same sidecar and the same lock file, so they must
+    // share the same in-flight promise.
+    static ensurePromise = null;
     constructor(options = {}) {
         this.baseUrl = options.baseUrl || `http://localhost:${ServerManager.DEFAULT_PORT}`;
         this.maxRetries = options.maxRetries || 30;
@@ -101,8 +123,21 @@ export class ServerManager {
     }
     /**
      * Ensure the server is running, starting it if necessary.
+     *
+     * Concurrent calls across all ServerManager instances in the process
+     * are coalesced onto a single in-flight promise. See the comment on
+     * `ServerManager.ensurePromise` for why this matters.
      */
     async ensureServerRunning() {
+        if (ServerManager.ensurePromise) {
+            return ServerManager.ensurePromise;
+        }
+        ServerManager.ensurePromise = this.doEnsureServerRunning().finally(() => {
+            ServerManager.ensurePromise = null;
+        });
+        return ServerManager.ensurePromise;
+    }
+    async doEnsureServerRunning() {
         // Check for force restart
         if (process.env.PMXT_ALWAYS_RESTART === '1') {
             await this.killOldServer();
@@ -201,6 +236,70 @@ export class ServerManager {
         await this.stop();
         await this.ensureServerRunning();
     }
+    /**
+     * Start the server if it is not already running.
+     *
+     * Idempotent: if the server is already running and healthy this returns
+     * immediately without restarting.
+     */
+    async start() {
+        await this.ensureServerRunning();
+    }
+    /**
+     * Get a structured snapshot of the sidecar server state.
+     *
+     * Returns a fresh object on every call (no shared mutable state).
+     */
+    async status() {
+        const info = this.getServerInfo();
+        const running = await this.isServerRunning();
+        let uptimeSeconds = null;
+        if (info && typeof info.timestamp === "number") {
+            const nowSeconds = Date.now() / 1000;
+            const tsSeconds = info.timestamp > 1e12 ? info.timestamp / 1000 : info.timestamp;
+            const delta = nowSeconds - tsSeconds;
+            if (delta >= 0)
+                uptimeSeconds = delta;
+        }
+        return {
+            running,
+            pid: info?.pid ?? null,
+            port: info?.port ?? null,
+            version: info?.version ?? null,
+            uptimeSeconds,
+            lockFile: this.lockPath,
+        };
+    }
+    /**
+     * Check whether the server's /health endpoint is currently responsive.
+     */
+    async health() {
+        return this.isServerRunning();
+    }
+    /**
+     * Return the last `n` lines from the sidecar server log file.
+     *
+     * The launcher writes server stdout/stderr to ~/.pmxt/server.log.
+     * Returns an empty array if no log file is present.
+     */
+    logs(n = 50) {
+        if (n <= 0)
+            return [];
+        const logPath = join(dirname(this.lockPath), "server.log");
+        try {
+            if (!existsSync(logPath))
+                return [];
+            const content = readFileSync(logPath, "utf-8");
+            const lines = content.split(/\r?\n/);
+            // split on a trailing newline produces an empty final element; drop it
+            if (lines.length > 0 && lines[lines.length - 1] === "")
+                lines.pop();
+            return lines.length > n ? lines.slice(lines.length - n) : lines;
+        }
+        catch {
+            return [];
+        }
+    }
     async killOldServer() {
         const info = this.getServerInfo();
         if (info && info.pid) {