@fluxpool/mcp-server 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Fluxpool
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,219 @@
+# @fluxpool/mcp-server
+
+Generate images and videos with [Fluxpool.ai](https://fluxpool.ai) from Claude,
+Cursor, or any MCP client — across Flux, Seedream, Seedance, Runway and more,
+billed against a single pool of Fluxpool credits.
+
+## Tools
+
+| Tool | What it does |
+| --- | --- |
+| `list_models` | The current model catalog — IDs and media type. Call first if unsure which model to use. |
+| `create_generation` | Submit an image or video generation. Returns a generation ID immediately. |
+| `check_generation` | Poll a generation's status; returns the URL once ready. |
+| `get_generation_details` | Full metadata for one generation — prompt, params, credits charged. |
+| `list_library` | Browse saved assets, filtered by media type or model. |
+| `get_balance` | Credit balance for the API key. |
+
+Generation is **asynchronous**: `create_generation` returns an ID, then
+`check_generation` is polled until the status is `completed`. Output URLs are
+presigned and **expire after one hour** — download promptly.
+
+## Get an API key
+
+Create one at **<https://app.fluxpool.ai/api>**. Keys look like `fp_live_…`.
+
+Treat it like a password: it can spend your credits. Put it in your MCP client
+config (below), never in a file you commit.
+
+## Setup
+
+Two ways to connect, both serving the same six tools.
+
+### Option 1 — Hosted endpoint (recommended)
+
+If your client supports remote MCP servers over HTTP, connect directly. No
+install, no local process, nothing to keep updated.
+
+**Endpoint:** `https://api.fluxpool.ai/v1/mcp`
+**Auth:** `Authorization: Bearer fp_live_…`
+
+<details>
+<summary>Claude Code</summary>
+
+```bash
+claude mcp add --transport http fluxpool https://api.fluxpool.ai/v1/mcp \
+  --header "Authorization: Bearer fp_live_your_key_here"
+```
+</details>
+
+<details>
+<summary>Claude Desktop / Claude web — custom connector</summary>
+
+Settings → Connectors → **Add custom connector**, then supply the URL
+`https://api.fluxpool.ai/v1/mcp` and the `Authorization` header above.
+</details>
+
+<details>
+<summary>Cursor — <code>.cursor/mcp.json</code></summary>
+
+```json
+{
+  "mcpServers": {
+    "fluxpool": {
+      "url": "https://api.fluxpool.ai/v1/mcp",
+      "headers": {
+        "Authorization": "Bearer fp_live_your_key_here"
+      }
+    }
+  }
+}
+```
+</details>
+
+### Option 2 — Local bridge via npx
+
+For clients that only speak **stdio**. This package is a thin bridge: it
+forwards JSON-RPC to the same hosted endpoint, so the tools are identical.
+
+No install step — `npx` fetches it on first run.
+
+<details open>
+<summary>Claude Desktop — <code>claude_desktop_config.json</code></summary>
+
+- **macOS** `~/Library/Application Support/Claude/claude_desktop_config.json`
+- **Windows** `%APPDATA%\Claude\claude_desktop_config.json`
+- **Linux** `~/.config/Claude/claude_desktop_config.json`
+
+```json
+{
+  "mcpServers": {
+    "fluxpool": {
+      "command": "npx",
+      "args": ["-y", "@fluxpool/mcp-server"],
+      "env": {
+        "FLUXPOOL_API_KEY": "fp_live_your_key_here"
+      }
+    }
+  }
+}
+```
+
+Restart Claude Desktop fully — quit and reopen, not just close the window.
+</details>
+
+<details>
+<summary>Cursor — <code>.cursor/mcp.json</code></summary>
+
+```json
+{
+  "mcpServers": {
+    "fluxpool": {
+      "command": "npx",
+      "args": ["-y", "@fluxpool/mcp-server"],
+      "env": {
+        "FLUXPOOL_API_KEY": "fp_live_your_key_here"
+      }
+    }
+  }
+}
+```
+</details>
+
+<details>
+<summary>Claude Code</summary>
+
+```bash
+claude mcp add fluxpool \
+  --env FLUXPOOL_API_KEY=fp_live_your_key_here \
+  -- npx -y @fluxpool/mcp-server
+```
+</details>
+
+Prefer a pinned global install over `npx`:
+
+```bash
+npm install -g @fluxpool/mcp-server
+```
+
+Then use `"command": "fluxpool-mcp"` with no `args`.
+
+## Verify it works
+
+Ask your client: **"List my Fluxpool models."** It should call `list_models`
+and print the catalog.
+
+To check the transport by hand:
+
+```bash
+printf '%s\n' '{"jsonrpc":"2.0","id":1,"method":"tools/list"}' \
+  | FLUXPOOL_API_KEY=fp_live_your_key_here npx -y @fluxpool/mcp-server
+```
+
+That prints one JSON line listing all six tools.
+
+## Configuration
+
+| Variable | Required | Default | Purpose |
+| --- | --- | --- | --- |
+| `FLUXPOOL_API_KEY` | yes | — | Your `fp_live_…` key. |
+| `FLUXPOOL_MCP_URL` | no | `https://api.fluxpool.ai/v1/mcp` | Point at a different backend (local or staging). |
+
+## Troubleshooting
+
+**"FLUXPOOL_API_KEY is not set"** — the key never reached the process. It goes
+in the `env` block of the server entry, not at the top level of the config.
+
+**"Invalid API key"** — the key was rejected. Confirm it is active at
+<https://app.fluxpool.ai/api>; revoked keys fail this way.
+
+**The server doesn't appear at all** — check the client's MCP logs. On Claude
+Desktop: `~/Library/Logs/Claude/mcp*.log` (macOS) or `%APPDATA%\Claude\logs\`
+(Windows). Diagnostics from this package are written to stderr and show up
+there. Also confirm `node --version` is 20 or newer.
+
+**Insufficient credits** — `create_generation` returns an
+`insufficient_credits` error carrying the required and available amounts. Top
+up at <https://app.fluxpool.ai/credits>.
+
+## How it works
+
+```
+MCP client  ──stdio──▶  @fluxpool/mcp-server  ──HTTPS──▶  api.fluxpool.ai/v1/mcp
+(Claude, Cursor)         (this package)                    (tools live here)
+```
+
+Tool definitions live on the server, not in this package, and reach clients
+verbatim via `tools/list`. That is deliberate: the hosted endpoint and this
+bridge expose one surface that cannot drift apart, and new tools become
+available without anyone upgrading a package.
+
+## Development
+
+```bash
+npm install
+npm run build     # tsc -> dist/
+npm test          # builds, then runs offline tests
+```
+
+Tests stub `fetch` and use a dummy key — they never touch the network.
+
+### Releasing
+
+```bash
+npm version patch && git push --follow-tags
+```
+
+CI builds, tests, checks the tag matches `package.json`, and publishes via
+npm Trusted Publishing (OIDC) — no npm token is stored in this repo.
+
+## Contributing
+
+Issues and pull requests: <https://github.com/ZKcandy/fluxpool-mcp-server/issues>
+
+Because tools are defined server-side, adding or changing one is a backend
+change rather than a change here. Open an issue describing the tool you need.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

package/dist/bridge.d.ts

@@ -0,0 +1,32 @@
+/**
+ * stdio <-> HTTP bridge.
+ *
+ * MCP clients that only speak stdio (Claude Desktop, Cursor) spawn this
+ * process and exchange newline-delimited JSON-RPC over stdin/stdout. Each
+ * inbound line is forwarded to Fluxpool's hosted MCP endpoint and the reply
+ * written back out.
+ *
+ * Two rules govern stdout and both are load-bearing:
+ *   - Exactly one JSON message per line, nothing else. Any stray write
+ *     corrupts the client's parser, which is why every log goes to stderr.
+ *   - Notifications (a message with no `id`) get no reply, ever. Answering
+ *     one is a protocol violation.
+ */
+import type { Readable, Writable } from 'node:stream';
+import { type FluxpoolClient } from './client.js';
+export interface BridgeOptions {
+    client: FluxpoolClient;
+    input?: Readable;
+    output?: Writable;
+    /** Defaults to stderr. Never stdout — that channel is the protocol. */
+    log?: (message: string) => void;
+}
+export declare class Bridge {
+    #private;
+    constructor(options: BridgeOptions);
+    /** Pump stdin until it closes. Resolves when the stream ends. */
+    run(): Promise<void>;
+    /** Process one inbound line. Exposed for tests. */
+    handleLine(line: string): Promise<void>;
+    private write;
+}

package/dist/bridge.js

@@ -0,0 +1,103 @@
+/**
+ * stdio <-> HTTP bridge.
+ *
+ * MCP clients that only speak stdio (Claude Desktop, Cursor) spawn this
+ * process and exchange newline-delimited JSON-RPC over stdin/stdout. Each
+ * inbound line is forwarded to Fluxpool's hosted MCP endpoint and the reply
+ * written back out.
+ *
+ * Two rules govern stdout and both are load-bearing:
+ *   - Exactly one JSON message per line, nothing else. Any stray write
+ *     corrupts the client's parser, which is why every log goes to stderr.
+ *   - Notifications (a message with no `id`) get no reply, ever. Answering
+ *     one is a protocol violation.
+ */
+import { createInterface } from 'node:readline';
+import { errorResponse } from './client.js';
+import { JSON_RPC } from './types.js';
+export class Bridge {
+    #client;
+    #input;
+    #output;
+    #log;
+    constructor(options) {
+        this.#client = options.client;
+        this.#input = options.input ?? process.stdin;
+        this.#output = options.output ?? process.stdout;
+        this.#log = options.log ?? ((message) => process.stderr.write(`${message}\n`));
+    }
+    /** Pump stdin until it closes. Resolves when the stream ends. */
+    async run() {
+        const lines = createInterface({ input: this.#input, crlfDelay: Infinity });
+        // Messages are handled sequentially. MCP clients do allow concurrent
+        // requests, but ordering keeps stdout writes interleaving-free and the
+        // upstream calls are fast enough that head-of-line blocking is not a
+        // practical concern for six short request/response tools.
+        for await (const line of lines) {
+            await this.handleLine(line);
+        }
+    }
+    /** Process one inbound line. Exposed for tests. */
+    async handleLine(line) {
+        const trimmed = line.trim();
+        // Blank lines are framing, not messages. Forwarding one would make the
+        // endpoint answer a parse error the client never asked for.
+        if (trimmed === '')
+            return;
+        let message;
+        try {
+            message = JSON.parse(trimmed);
+        }
+        catch {
+            // Can't recover an id from unparseable input, so per JSON-RPC the id
+            // is null.
+            this.write(errorResponse(null, JSON_RPC.PARSE_ERROR, 'Invalid JSON received by the Fluxpool MCP bridge'));
+            return;
+        }
+        const id = extractId(message);
+        let response;
+        try {
+            response = await this.#client.send(message, id);
+        }
+        catch (cause) {
+            // The client is written not to throw, so reaching here means a bug
+            // rather than an expected failure. Report it instead of dying: killing
+            // the process would drop the client's whole session.
+            this.#log(`[fluxpool-mcp] unexpected bridge error: ${describe(cause)}`);
+            if (id === null)
+                return;
+            response = errorResponse(id, JSON_RPC.INTERNAL_ERROR, `Bridge error: ${describe(cause)}`);
+        }
+        if (response === null)
+            return; // notification — stay silent
+        this.write(response);
+    }
+    #writeRaw(payload) {
+        this.#output.write(`${JSON.stringify(payload)}\n`);
+    }
+    write(payload) {
+        this.#writeRaw(payload);
+    }
+}
+/**
+ * Pull the id out of an inbound message so a synthesised error can be
+ * addressed correctly.
+ *
+ * Returns null for notifications AND for batches. A batch has no single id;
+ * a transport failure mid-batch is reported as an id-less error, which is
+ * what the spec prescribes for a request that could not be routed.
+ */
+function extractId(message) {
+    if (Array.isArray(message))
+        return null;
+    if (typeof message !== 'object' || message === null)
+        return null;
+    const id = message.id;
+    if (typeof id === 'string' || typeof id === 'number')
+        return id;
+    return null;
+}
+function describe(cause) {
+    return cause instanceof Error ? cause.message : String(cause);
+}
+//# sourceMappingURL=bridge.js.map

package/dist/bridge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridge.js","sourceRoot":"","sources":["../src/bridge.ts"],"names":[],"mappings":"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"}

package/dist/client.d.ts

@@ -0,0 +1,43 @@
+/**
+ * HTTP client for Fluxpool's hosted MCP endpoint.
+ *
+ * One job: POST a JSON-RPC message and hand back what came out, normalising
+ * the cases where the endpoint answers with something that isn't JSON-RPC.
+ *
+ * Three responses have to be told apart, and the distinction matters because
+ * writing the wrong thing to stdout corrupts the client's protocol stream:
+ *
+ *   1. A JSON-RPC response  -> relay verbatim.
+ *   2. HTTP 202, empty body -> a notification was accepted. Return null; the
+ *      caller must stay silent, because notifications take no reply.
+ *   3. An auth/HTTP error   -> arrives as OpenAI-shaped `{error:{message}}`
+ *      with no `jsonrpc` field, since auth is checked before the JSON-RPC
+ *      dispatcher runs. Convert to a proper JSON-RPC error.
+ */
+import { type JsonRpcId, type JsonRpcResponse, type JsonValue, type Outbound } from './types.js';
+export declare const DEFAULT_MCP_URL = "https://api.fluxpool.ai/v1/mcp";
+export interface FluxpoolClientOptions {
+    apiKey: string;
+    /** Override the endpoint (local backend, staging). Defaults to production. */
+    url?: string;
+    /** Abort a request after this many ms. Defaults to 10 minutes. */
+    timeoutMs?: number;
+    /** Injection seam for tests — defaults to global fetch. */
+    fetchImpl?: typeof fetch;
+}
+export declare class FluxpoolClient {
+    #private;
+    constructor(options: FluxpoolClientOptions);
+    get url(): string;
+    /**
+     * Forward one JSON-RPC message (or batch) upstream.
+     *
+     * @param message  Already-parsed JSON-RPC payload from the client.
+     * @param id       Id to attach to any error we synthesise. Pass null for
+     *                 notifications so a failure can be dropped rather than
+     *                 sent back as a reply to a message that expects none.
+     * @returns The upstream response, or null when there is nothing to send.
+     */
+    send(message: JsonValue, id: JsonRpcId): Promise<Outbound | null>;
+}
+export declare function errorResponse(id: JsonRpcId, code: number, message: string, data?: JsonValue): JsonRpcResponse;

package/dist/client.js

@@ -0,0 +1,138 @@
+/**
+ * HTTP client for Fluxpool's hosted MCP endpoint.
+ *
+ * One job: POST a JSON-RPC message and hand back what came out, normalising
+ * the cases where the endpoint answers with something that isn't JSON-RPC.
+ *
+ * Three responses have to be told apart, and the distinction matters because
+ * writing the wrong thing to stdout corrupts the client's protocol stream:
+ *
+ *   1. A JSON-RPC response  -> relay verbatim.
+ *   2. HTTP 202, empty body -> a notification was accepted. Return null; the
+ *      caller must stay silent, because notifications take no reply.
+ *   3. An auth/HTTP error   -> arrives as OpenAI-shaped `{error:{message}}`
+ *      with no `jsonrpc` field, since auth is checked before the JSON-RPC
+ *      dispatcher runs. Convert to a proper JSON-RPC error.
+ */
+import { JSON_RPC, isRestError, } from './types.js';
+export const DEFAULT_MCP_URL = 'https://api.fluxpool.ai/v1/mcp';
+/**
+ * Video generation is submitted asynchronously, so no single call should be
+ * slow — but a client may still be mid-poll when a network hiccup stalls the
+ * socket. Ten minutes is generous enough never to fire in normal use while
+ * still guaranteeing the process can't hang forever on a dead connection.
+ */
+const DEFAULT_TIMEOUT_MS = 10 * 60 * 1000;
+export class FluxpoolClient {
+    #apiKey;
+    #url;
+    #timeoutMs;
+    #fetch;
+    constructor(options) {
+        this.#apiKey = options.apiKey;
+        this.#url = options.url ?? DEFAULT_MCP_URL;
+        this.#timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        this.#fetch = options.fetchImpl ?? globalThis.fetch;
+    }
+    get url() {
+        return this.#url;
+    }
+    /**
+     * Forward one JSON-RPC message (or batch) upstream.
+     *
+     * @param message  Already-parsed JSON-RPC payload from the client.
+     * @param id       Id to attach to any error we synthesise. Pass null for
+     *                 notifications so a failure can be dropped rather than
+     *                 sent back as a reply to a message that expects none.
+     * @returns The upstream response, or null when there is nothing to send.
+     */
+    async send(message, id) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.#timeoutMs);
+        let response;
+        try {
+            response = await this.#fetch(this.#url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Accept: 'application/json',
+                    Authorization: `Bearer ${this.#apiKey}`,
+                },
+                body: JSON.stringify(message),
+                signal: controller.signal,
+            });
+        }
+        catch (cause) {
+            // Network failure, DNS, TLS, or our own abort. A notification has no
+            // reply channel, so there is nothing useful to return.
+            if (id === null)
+                return null;
+            const reason = cause instanceof Error && cause.name === 'AbortError'
+                ? `Request timed out after ${this.#timeoutMs}ms`
+                : `Could not reach ${this.#url}: ${describe(cause)}`;
+            return errorResponse(id, JSON_RPC.TRANSPORT_ERROR, reason);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+        const text = (await response.text()).trim();
+        // 202 + empty body: a notification was accepted. Nothing to relay.
+        if (text === '')
+            return null;
+        let parsed;
+        try {
+            parsed = JSON.parse(text);
+        }
+        catch {
+            if (id === null)
+                return null;
+            return errorResponse(id, JSON_RPC.TRANSPORT_ERROR, `Fluxpool returned a non-JSON response (HTTP ${response.status}): ${truncate(text)}`);
+        }
+        // Auth rejections and other pre-dispatch failures arrive in the REST
+        // error shape. Translate so the client sees valid JSON-RPC.
+        if (!response.ok && isRestError(parsed)) {
+            if (id === null)
+                return null;
+            const code = response.status === 401 || response.status === 403
+                ? JSON_RPC.AUTH_ERROR
+                : JSON_RPC.TRANSPORT_ERROR;
+            const hint = code === JSON_RPC.AUTH_ERROR
+                ? ' Check that FLUXPOOL_API_KEY is a valid key from https://app.fluxpool.ai/api'
+                : '';
+            return errorResponse(id, code, `${parsed.error.message}${hint}`, {
+                http_status: response.status,
+                code: parsed.error.code ?? null,
+            });
+        }
+        // Anything else that isn't JSON-RPC — an unexpected gateway body, say.
+        if (!response.ok && !isPassThrough(parsed)) {
+            if (id === null)
+                return null;
+            return errorResponse(id, JSON_RPC.TRANSPORT_ERROR, `Fluxpool returned HTTP ${response.status}: ${truncate(text)}`);
+        }
+        return parsed;
+    }
+}
+/** JSON-RPC responses and batches thereof pass through untouched. */
+function isPassThrough(value) {
+    if (Array.isArray(value))
+        return true;
+    return (typeof value === 'object' &&
+        value !== null &&
+        value.jsonrpc === '2.0');
+}
+export function errorResponse(id, code, message, data) {
+    const error = { code, message };
+    if (data !== undefined)
+        error.data = data;
+    return { jsonrpc: '2.0', id, error };
+}
+function describe(cause) {
+    if (cause instanceof Error)
+        return cause.message;
+    return String(cause);
+}
+function truncate(text, max = 200) {
+    return text.length <= max ? text : `${text.slice(0, max)}...`;
+}
+//# sourceMappingURL=client.js.map

package/dist/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+/**
+ * @fluxpool/mcp-server — entry point.
+ *
+ * Reads FLUXPOOL_API_KEY from the environment, opens the stdio bridge to
+ * Fluxpool's hosted MCP endpoint, and relays until stdin closes.
+ *
+ * Tools are NOT defined here. They are served by the backend and reach the
+ * client verbatim through `tools/list`, so the two MCP surfaces — hosted
+ * HTTP and this local stdio bridge — can never drift apart.
+ */
+export declare function main(env?: NodeJS.ProcessEnv): Promise<number>;

package/dist/index.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+/**
+ * @fluxpool/mcp-server — entry point.
+ *
+ * Reads FLUXPOOL_API_KEY from the environment, opens the stdio bridge to
+ * Fluxpool's hosted MCP endpoint, and relays until stdin closes.
+ *
+ * Tools are NOT defined here. They are served by the backend and reach the
+ * client verbatim through `tools/list`, so the two MCP surfaces — hosted
+ * HTTP and this local stdio bridge — can never drift apart.
+ */
+import { Bridge } from './bridge.js';
+import { pathToFileURL } from 'node:url';
+import { DEFAULT_MCP_URL, FluxpoolClient } from './client.js';
+/** Log to stderr. stdout carries the protocol and must stay clean. */
+function log(message) {
+    process.stderr.write(`${message}\n`);
+}
+export async function main(env = process.env) {
+    const apiKey = env.FLUXPOOL_API_KEY?.trim();
+    if (!apiKey) {
+        log([
+            'fluxpool-mcp: FLUXPOOL_API_KEY is not set.',
+            '',
+            'Create a key at https://app.fluxpool.ai/api, then add it to your MCP',
+            'client config. For Claude Desktop that means an "env" block:',
+            '',
+            '  "mcpServers": {',
+            '    "fluxpool": {',
+            '      "command": "npx",',
+            '      "args": ["-y", "@fluxpool/mcp-server"],',
+            '      "env": { "FLUXPOOL_API_KEY": "fp_live_..." }',
+            '    }',
+            '  }',
+            '',
+            'See https://github.com/ZKcandy/fluxpool-mcp-server#setup for other clients.',
+        ].join('\n'));
+        return 1;
+    }
+    // Warn but continue: a malformed key still reaches the endpoint, and its
+    // 401 is more informative than anything guessed here. Key formats also
+    // change more often than this package ships.
+    if (!apiKey.startsWith('fp_live_')) {
+        log('fluxpool-mcp: warning — FLUXPOOL_API_KEY does not start with "fp_live_". Continuing anyway.');
+    }
+    const url = env.FLUXPOOL_MCP_URL?.trim() || DEFAULT_MCP_URL;
+    const client = new FluxpoolClient({ apiKey, url });
+    if (url !== DEFAULT_MCP_URL)
+        log(`fluxpool-mcp: using endpoint ${url}`);
+    await new Bridge({ client, log }).run();
+    return 0;
+}
+// Run only when executed directly, so tests can import main() freely.
+// process.argv[1] is the resolved script path; compare against this module.
+const invokedDirectly = process.argv[1] !== undefined &&
+    import.meta.url === pathToFileURL(process.argv[1]).href;
+if (invokedDirectly) {
+    main()
+        .then((code) => {
+        process.exitCode = code;
+    })
+        .catch((cause) => {
+        log(`fluxpool-mcp: fatal — ${cause instanceof Error ? cause.message : String(cause)}`);
+        process.exitCode = 1;
+    });
+}
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AACA;;;;;;;;;GASG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEzC,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAE9D,sEAAsE;AACtE,SAAS,GAAG,CAAC,OAAe;IAC1B,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,OAAO,IAAI,CAAC,CAAC;AACvC,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,IAAI,CAAC,MAAyB,OAAO,CAAC,GAAG;IAC7D,MAAM,MAAM,GAAG,GAAG,CAAC,gBAAgB,EAAE,IAAI,EAAE,CAAC;IAE5C,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,GAAG,CACD;YACE,4CAA4C;YAC5C,EAAE;YACF,sEAAsE;YACtE,8DAA8D;YAC9D,EAAE;YACF,mBAAmB;YACnB,mBAAmB;YACnB,yBAAyB;YACzB,+CAA+C;YAC/C,oDAAoD;YACpD,OAAO;YACP,KAAK;YACL,EAAE;YACF,6EAA6E;SAC9E,CAAC,IAAI,CAAC,IAAI,CAAC,CACb,CAAC;QACF,OAAO,CAAC,CAAC;IACX,CAAC;IAED,yEAAyE;IACzE,uEAAuE;IACvE,6CAA6C;IAC7C,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,UAAU,CAAC,EAAE,CAAC;QACnC,GAAG,CAAC,6FAA6F,CAAC,CAAC;IACrG,CAAC;IAED,MAAM,GAAG,GAAG,GAAG,CAAC,gBAAgB,EAAE,IAAI,EAAE,IAAI,eAAe,CAAC;IAC5D,MAAM,MAAM,GAAG,IAAI,cAAc,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC;IAEnD,IAAI,GAAG,KAAK,eAAe;QAAE,GAAG,CAAC,gCAAgC,GAAG,EAAE,CAAC,CAAC;IAExE,MAAM,IAAI,MAAM,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,GAAG,EAAE,CAAC;IACxC,OAAO,CAAC,CAAC;AACX,CAAC;AAED,sEAAsE;AACtE,4EAA4E;AAC5E,MAAM,eAAe,GACnB,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,SAAS;IAC7B,MAAM,CAAC,IAAI,CAAC,GAAG,KAAK,aAAa,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;AAE1D,IAAI,eAAe,EAAE,CAAC;IACpB,IAAI,EAAE;SACH,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE;QACb,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC;IAC1B,CAAC,CAAC;SACD,KAAK,CAAC,CAAC,KAAc,EAAE,EAAE;QACxB,GAAG,CAAC,yBAAyB,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;QACvF,OAAO,CAAC,QAAQ,GAAG,CAAC,CAAC;IACvB,CAAC,CAAC,CAAC;AACP,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,82 @@
+/**
+ * JSON-RPC 2.0 + Fluxpool REST types.
+ *
+ * This package is a transport bridge, not a tool implementation: it relays
+ * JSON-RPC messages between a stdio MCP client and Fluxpool's hosted MCP
+ * endpoint. So the types here describe the *envelope*, not the tools. Tool
+ * schemas live on the backend (`functions/ingestion/index.js`) and reach
+ * clients verbatim via `tools/list` — deliberately, so the two surfaces can
+ * never drift.
+ */
+/** A JSON value, as far as JSON-RPC is concerned. */
+export type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+/**
+ * JSON-RPC request id. Per spec this is a string, number, or null.
+ * A message with NO id is a notification and must not be replied to.
+ */
+export type JsonRpcId = string | number | null;
+/** A single JSON-RPC 2.0 request or notification travelling client -> server. */
+export type JsonRpcRequest = {
+    jsonrpc: '2.0';
+    method: string;
+    /** Absent means notification: the server must stay silent. */
+    id?: JsonRpcId;
+    params?: JsonValue;
+};
+/** A single JSON-RPC 2.0 response travelling server -> client. */
+export type JsonRpcResponse = {
+    jsonrpc: '2.0';
+    id: JsonRpcId;
+    result?: JsonValue;
+    error?: JsonRpcErrorObject;
+};
+export type JsonRpcErrorObject = {
+    code: number;
+    message: string;
+    data?: JsonValue;
+};
+/**
+ * Standard JSON-RPC error codes, plus the implementation-defined range we
+ * use for transport failures. -32000..-32099 is reserved for the server to
+ * define, which is where an HTTP-layer problem belongs: the request never
+ * reached a method handler.
+ */
+export declare const JSON_RPC: {
+    readonly PARSE_ERROR: -32700;
+    readonly INVALID_REQUEST: -32600;
+    readonly METHOD_NOT_FOUND: -32601;
+    readonly INVALID_PARAMS: -32602;
+    readonly INTERNAL_ERROR: -32603;
+    /** Transport-level failure talking to the Fluxpool endpoint. */
+    readonly TRANSPORT_ERROR: -32001;
+    /** Auth rejected (bad or missing API key). */
+    readonly AUTH_ERROR: -32002;
+};
+/**
+ * Fluxpool's REST error envelope. The hosted MCP endpoint returns JSON-RPC
+ * for anything that reaches the dispatcher, but auth is checked *before*
+ * that — so a 401 arrives in this OpenAI-compatible shape with no `jsonrpc`
+ * field at all. The bridge has to recognise and translate it.
+ */
+export interface FluxpoolRestError {
+    error: {
+        message: string;
+        type?: string;
+        param?: string | null;
+        code?: string;
+    };
+}
+/** Narrowing helper for the REST error shape above. */
+export declare function isRestError(value: unknown): value is FluxpoolRestError;
+/** True when a parsed payload already looks like JSON-RPC we can pass through. */
+export declare function isJsonRpcMessage(value: unknown): boolean;
+/**
+ * What the bridge writes to stdout: either a payload relayed verbatim from
+ * upstream (an opaque `JsonValue` — we do not re-validate what the backend
+ * sends) or an error this package synthesised. Keeping the union explicit
+ * avoids laundering typed shapes through `JsonValue`, which drops the very
+ * guarantees the types exist to provide.
+ */
+export type Outbound = JsonValue | JsonRpcResponse;

package/dist/types.js

@@ -0,0 +1,43 @@
+/**
+ * JSON-RPC 2.0 + Fluxpool REST types.
+ *
+ * This package is a transport bridge, not a tool implementation: it relays
+ * JSON-RPC messages between a stdio MCP client and Fluxpool's hosted MCP
+ * endpoint. So the types here describe the *envelope*, not the tools. Tool
+ * schemas live on the backend (`functions/ingestion/index.js`) and reach
+ * clients verbatim via `tools/list` — deliberately, so the two surfaces can
+ * never drift.
+ */
+/**
+ * Standard JSON-RPC error codes, plus the implementation-defined range we
+ * use for transport failures. -32000..-32099 is reserved for the server to
+ * define, which is where an HTTP-layer problem belongs: the request never
+ * reached a method handler.
+ */
+export const JSON_RPC = {
+    PARSE_ERROR: -32700,
+    INVALID_REQUEST: -32600,
+    METHOD_NOT_FOUND: -32601,
+    INVALID_PARAMS: -32602,
+    INTERNAL_ERROR: -32603,
+    /** Transport-level failure talking to the Fluxpool endpoint. */
+    TRANSPORT_ERROR: -32001,
+    /** Auth rejected (bad or missing API key). */
+    AUTH_ERROR: -32002,
+};
+/** Narrowing helper for the REST error shape above. */
+export function isRestError(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const err = value.error;
+    if (typeof err !== 'object' || err === null)
+        return false;
+    return typeof err.message === 'string';
+}
+/** True when a parsed payload already looks like JSON-RPC we can pass through. */
+export function isJsonRpcMessage(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    return value.jsonrpc === '2.0';
+}
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAwCH;;;;;GAKG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG;IACtB,WAAW,EAAE,CAAC,KAAK;IACnB,eAAe,EAAE,CAAC,KAAK;IACvB,gBAAgB,EAAE,CAAC,KAAK;IACxB,cAAc,EAAE,CAAC,KAAK;IACtB,cAAc,EAAE,CAAC,KAAK;IACtB,gEAAgE;IAChE,eAAe,EAAE,CAAC,KAAK;IACvB,8CAA8C;IAC9C,UAAU,EAAE,CAAC,KAAK;CACV,CAAC;AAiBX,uDAAuD;AACvD,MAAM,UAAU,WAAW,CAAC,KAAc;IACxC,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC;IAC9D,MAAM,GAAG,GAAI,KAA6B,CAAC,KAAK,CAAC;IACjD,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,GAAG,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC;IAC1D,OAAO,OAAQ,GAA6B,CAAC,OAAO,KAAK,QAAQ,CAAC;AACpE,CAAC;AAED,kFAAkF;AAClF,MAAM,UAAU,gBAAgB,CAAC,KAAc;IAC7C,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC;IAC9D,OAAQ,KAA+B,CAAC,OAAO,KAAK,KAAK,CAAC;AAC5D,CAAC"}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@fluxpool/mcp-server",
+  "version": "0.1.0",
+  "description": "MCP server for Fluxpool.ai — generate images and videos across Flux, Seedream, Seedance, Runway and more from Claude, Cursor, or any MCP client.",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "fluxpool",
+    "ai",
+    "image-generation",
+    "video-generation",
+    "claude",
+    "cursor"
+  ],
+  "homepage": "https://fluxpool.ai",
+  "bugs": {
+    "url": "https://github.com/ZKcandy/fluxpool-mcp-server/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ZKcandy/fluxpool-mcp-server.git"
+  },
+  "license": "MIT",
+  "author": "Fluxpool",
+  "type": "module",
+  "bin": {
+    "fluxpool-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build && npm test",
+    "start": "node dist/index.js",
+    "test": "npm run build && node --test test/"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.4"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "typescript": "^5.7.2"
+  }
+}