@pmxt/mcp 0.1.0

package/dist/args.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Reconstruct the positional args array from flat MCP tool input.
+ *
+ * MCP tools receive a flat { key: value } object. The PMXT REST API
+ * expects a positional args array: POST body { args: [...] }.
+ *
+ * This module bridges the two using the ArgSpec metadata embedded in
+ * each generated tool definition.
+ */
+import type { ArgSpec } from "./generated/tools.js";
+/**
+ * Given a flat input object (with exchange and credentials already
+ * removed) and the arg spec for the method, produce the positional
+ * args array the sidecar expects.
+ */
+export declare function reconstructArgs(input: Record<string, unknown>, argSpec: readonly ArgSpec[]): unknown[];

package/dist/args.js

@@ -0,0 +1,42 @@
+/**
+ * Reconstruct the positional args array from flat MCP tool input.
+ *
+ * MCP tools receive a flat { key: value } object. The PMXT REST API
+ * expects a positional args array: POST body { args: [...] }.
+ *
+ * This module bridges the two using the ArgSpec metadata embedded in
+ * each generated tool definition.
+ */
+/**
+ * Given a flat input object (with exchange and credentials already
+ * removed) and the arg spec for the method, produce the positional
+ * args array the sidecar expects.
+ */
+export function reconstructArgs(input, argSpec) {
+    const args = [];
+    // Names of non-flattened args so we can exclude them when collecting
+    // properties for a flattened object arg.
+    const namedArgs = new Set(argSpec.filter((s) => !s.flatten).map((s) => s.name));
+    for (const spec of argSpec) {
+        if (spec.flatten) {
+            // This arg's properties were spread into the top-level input.
+            // Collect everything that isn't a named primitive arg.
+            const obj = {};
+            for (const [key, value] of Object.entries(input)) {
+                if (!namedArgs.has(key) && value !== undefined) {
+                    obj[key] = value;
+                }
+            }
+            args.push(Object.keys(obj).length > 0 ? obj : undefined);
+        }
+        else {
+            const value = input[spec.name];
+            args.push(value !== undefined ? value : undefined);
+        }
+    }
+    // Trim trailing undefineds so optional tail params stay optional.
+    while (args.length > 0 && args[args.length - 1] === undefined) {
+        args.pop();
+    }
+    return args;
+}

package/dist/client.d.ts

@@ -0,0 +1,15 @@
+/**
+ * HTTP client for the PMXT REST API.
+ *
+ * Every MCP tool call becomes a POST to /api/{exchange}/{method} with
+ * the standard { args, credentials? } body shape. POST works for all
+ * endpoints (reads and writes) on both the hosted API and the sidecar.
+ */
+import type { Config } from "./config.js";
+export interface CallOptions {
+    readonly exchange: string;
+    readonly method: string;
+    readonly args: unknown[];
+    readonly credentials?: Record<string, unknown>;
+}
+export declare function callPmxtApi(config: Config, options: CallOptions): Promise<unknown>;

package/dist/client.js

@@ -0,0 +1,36 @@
+/**
+ * HTTP client for the PMXT REST API.
+ *
+ * Every MCP tool call becomes a POST to /api/{exchange}/{method} with
+ * the standard { args, credentials? } body shape. POST works for all
+ * endpoints (reads and writes) on both the hosted API and the sidecar.
+ */
+export async function callPmxtApi(config, options) {
+    const url = `${config.apiUrl}/api/${encodeURIComponent(options.exchange)}/${encodeURIComponent(options.method)}`;
+    const headers = {
+        "Content-Type": "application/json",
+    };
+    if (config.apiKey) {
+        headers["Authorization"] = `Bearer ${config.apiKey}`;
+    }
+    const body = { args: options.args };
+    if (options.credentials && Object.keys(options.credentials).length > 0) {
+        body.credentials = options.credentials;
+    }
+    const response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body),
+    });
+    const json = (await response.json());
+    if (!response.ok || json.success === false) {
+        const err = json.error;
+        const message = typeof err === "string"
+            ? err
+            : typeof err === "object" && err !== null
+                ? err.message || JSON.stringify(err)
+                : response.statusText;
+        throw new Error(message);
+    }
+    return json.data;
+}

package/dist/config.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Environment-based configuration for the PMXT MCP server.
+ *
+ * Precedence mirrors the SDK: PMXT_API_URL overrides everything,
+ * otherwise default to the hosted endpoint when an API key is present
+ * or localhost when running alongside the sidecar.
+ */
+export interface Config {
+    readonly apiUrl: string;
+    readonly apiKey: string | undefined;
+}
+export declare function loadConfig(): Config;

package/dist/config.js

@@ -0,0 +1,24 @@
+/**
+ * Environment-based configuration for the PMXT MCP server.
+ *
+ * Precedence mirrors the SDK: PMXT_API_URL overrides everything,
+ * otherwise default to the hosted endpoint when an API key is present
+ * or localhost when running alongside the sidecar.
+ */
+const HOSTED_URL = "https://api.pmxt.dev";
+const LOCAL_URL = "http://localhost:3847";
+export function loadConfig() {
+    const apiKey = process.env.PMXT_API_KEY || undefined;
+    const explicit = process.env.PMXT_API_URL;
+    let apiUrl;
+    if (explicit) {
+        apiUrl = explicit;
+    }
+    else if (apiKey) {
+        apiUrl = HOSTED_URL;
+    }
+    else {
+        apiUrl = LOCAL_URL;
+    }
+    return Object.freeze({ apiUrl, apiKey });
+}

package/dist/generated/tools.d.ts

@@ -0,0 +1,15 @@
+export interface ArgSpec {
+    name: string;
+    kind: string;
+    optional: boolean;
+    flatten: boolean;
+}
+export interface ToolDef {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+    annotations: Record<string, boolean>;
+    method: string;
+    args: ArgSpec[];
+}
+export declare const TOOLS: ToolDef[];