@infigure/mcp-bridge 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Infigure
+
+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,103 @@
+# @infigure/mcp-bridge
+
+A local stdin/stdout JSON-RPC proxy for the Infigure MCP server.
+
+Since local AI clients (such as Claude Code, Claude Desktop, or Codex) communicate via stdio streams, this bridge translates stdio JSON-RPC payloads into HTTP requests forwarded to the remote Infigure API.
+
+---
+
+## Setup
+
+### 1. Configure Credentials
+Run the interactive setup to configure target host URL, Personal Access Token (PAT), and default Team ID:
+
+```bash
+npx @infigure/mcp-bridge configure
+```
+
+This saves configurations securely to `~/.infigure/credentials` with `0o600` permissions.
+
+### 2. Verify Connection
+Verify the connection and authentication state by running:
+
+```bash
+npx @infigure/mcp-bridge whoami
+```
+
+### 3. Automatically Install to AI Clients
+Register the server config with your client config file automatically:
+
+```bash
+# Register with Claude Code (~/.claude.json)
+npx @infigure/mcp-bridge install claude-code
+
+# Register with Claude Desktop (macOS, Windows, or Linux configs)
+npx @infigure/mcp-bridge install claude-desktop
+
+# Register with Codex (~/.codex/config.toml)
+npx @infigure/mcp-bridge install codex
+
+# Register with ALL available clients
+npx @infigure/mcp-bridge install all
+```
+
+---
+
+## Manual Integration Configs
+
+If you prefer to update client configs manually, use the following configurations:
+
+### Claude Desktop
+Target file: `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS)
+
+```json
+{
+  "mcpServers": {
+    "infigure": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@infigure/mcp-bridge"
+      ]
+    }
+  }
+}
+```
+
+### Cursor
+Add new MCP server:
+* **Name**: `infigure`
+* **Type**: `stdio`
+* **Command**: `npx -y @infigure/mcp-bridge`
+
+---
+
+## Command Interface
+
+```bash
+infigure-mcp [command] [options]
+```
+
+### Commands
+* **`serve`** (default): Starts standard input/output JSON-RPC proxy.
+* **`configure`**: Prompts for credentials.
+* **`whoami`**: Validates credentials with the server.
+* **`install <name>`**: Configures client. Options: `claude-code`, `claude-desktop`, `codex`, `all`.
+
+### Options
+* `-u, --url <url>`: Target URL (default: `https://www.infigured.com`).
+* `-t, --token <token>`: Personal Access Token (PAT).
+* `-m, --team-id <id>`: Workspace Team ID.
+* `-v, --verbose`: Log JSON-RPC traffic on stderr.
+* `-h, --help`: Output help.
+
+---
+
+## Debugging
+
+To trace JSON-RPC messages and check API status logs, run:
+
+```bash
+npx @infigure/mcp-bridge --verbose
+```
+*Note: All diagnostics and connection states are logged to `stderr` to prevent JSON-RPC stream corruption.*

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,456 @@
+#!/usr/bin/env node
+import fs from "fs";
+import path from "path";
+import os from "os";
+import readline from "readline";
+const CREDENTIALS_PATH = path.join(os.homedir(), ".infigure", "credentials");
+const DEFAULT_URL = "https://www.infigured.com";
+const USAGE = `Infigure MCP Bridge
+
+Usage:
+  npx @infigure/mcp-bridge [command] [options]
+  infigure-mcp [command] [options]
+
+Commands:
+  serve           Start stdio-to-HTTP JSON-RPC proxy (default)
+  configure       Set up ~/.infigure/credentials file
+  whoami          Verify target URL and authentication status
+  install <name>  Register config with local client (claude-code | claude-desktop | codex | all)
+
+Options:
+  -u, --url <url>      API URL (default: ${DEFAULT_URL})
+  -t, --token <token>  Personal Access Token (PAT)
+  -m, --team-id <id>   Team/Workspace ID
+  -v, --verbose        Log JSON-RPC traffic to stderr
+  -h, --help           Show help
+`;
+function parseArgs() {
+    const args = process.argv.slice(2);
+    const config = {
+        command: "serve",
+        installClient: "",
+        url: "",
+        token: "",
+        teamId: "",
+        verbose: false,
+        help: false,
+    };
+    if (args[0] === "configure") {
+        config.command = "configure";
+        args.shift();
+    }
+    else if (args[0] === "whoami") {
+        config.command = "whoami";
+        args.shift();
+    }
+    else if (args[0] === "install") {
+        config.command = "install";
+        args.shift();
+        config.installClient = args[0] || "";
+        if (config.installClient && !config.installClient.startsWith("-")) {
+            args.shift();
+        }
+    }
+    else if (args[0] === "serve") {
+        config.command = "serve";
+        args.shift();
+    }
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "--help" || arg === "-h") {
+            config.help = true;
+        }
+        else if (arg === "--verbose" || arg === "-v") {
+            config.verbose = true;
+        }
+        else if (arg.startsWith("--url=")) {
+            config.url = arg.substring(6);
+        }
+        else if (arg === "--url" || arg === "-u") {
+            config.url = args[++i] || "";
+        }
+        else if (arg.startsWith("--token=")) {
+            config.token = arg.substring(8);
+        }
+        else if (arg === "--token" || arg === "-t") {
+            config.token = args[++i] || "";
+        }
+        else if (arg.startsWith("--team-id=")) {
+            config.teamId = arg.substring(10);
+        }
+        else if (arg === "--team-id" || arg === "-m") {
+            config.teamId = args[++i] || "";
+        }
+    }
+    return config;
+}
+function loadCredentialsFile() {
+    if (fs.existsSync(CREDENTIALS_PATH)) {
+        try {
+            return JSON.parse(fs.readFileSync(CREDENTIALS_PATH, "utf8"));
+        }
+        catch (e) {
+            console.error(`[Infigure MCP] Warning: Failed to parse credentials: ${e}`);
+        }
+    }
+    return {};
+}
+function resolveCredentials(cliConfig) {
+    const envBaseUrl = process.env.INFIGURE_BASE_URL;
+    const envToken = process.env.INFIGURE_TOKEN;
+    const envTeamId = process.env.INFIGURE_TEAM_ID;
+    const fileData = loadCredentialsFile();
+    const baseUrl = cliConfig.url || envBaseUrl || fileData.base_url || DEFAULT_URL;
+    const token = cliConfig.token || envToken || fileData.token || "";
+    const teamId = cliConfig.teamId || envTeamId || fileData.team_id || "";
+    return {
+        baseUrl: baseUrl.replace(/\/$/, ""),
+        token,
+        teamId,
+    };
+}
+function ensureCredentialsOrExit(creds) {
+    if (!creds.token || !creds.teamId) {
+        console.error("Error: Credentials or Team ID not configured.\n\n" +
+            "Provide them via args, env vars, or run:\n" +
+            "  infigure-mcp configure");
+        process.exit(1);
+    }
+}
+function askQuestion(query) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(query, (ans) => {
+            rl.close();
+            resolve(ans.trim());
+        });
+    });
+}
+async function runConfigure() {
+    const current = loadCredentialsFile();
+    const baseUrl = await askQuestion(`Infigure URL [${current.base_url || DEFAULT_URL}]: `);
+    const token = await askQuestion(`Personal Access Token [${current.token ? "********" : "none"}]: `);
+    const teamId = await askQuestion(`Default Team ID [${current.team_id || "none"}]: `);
+    const finalUrl = baseUrl || current.base_url || DEFAULT_URL;
+    const finalToken = token || current.token || "";
+    const finalTeamId = teamId || current.team_id || "";
+    if (!finalToken || !finalTeamId) {
+        console.error("Error: Token and Team ID are required.");
+        process.exit(1);
+    }
+    const data = {
+        base_url: finalUrl.replace(/\/$/, ""),
+        token: finalToken,
+        team_id: finalTeamId,
+    };
+    try {
+        const parentDir = path.dirname(CREDENTIALS_PATH);
+        if (!fs.existsSync(parentDir)) {
+            fs.mkdirSync(parentDir, { recursive: true });
+        }
+        fs.writeFileSync(CREDENTIALS_PATH, JSON.stringify(data, null, 2) + "\n", {
+            mode: 0o600,
+        });
+        try {
+            fs.chmodSync(CREDENTIALS_PATH, 0o600);
+        }
+        catch { }
+        console.log(`Configuration saved to ${CREDENTIALS_PATH}`);
+    }
+    catch (err) {
+        console.error(`Error: Failed to write credentials file: ${err.message}`);
+        process.exit(1);
+    }
+}
+async function runWhoAmI(creds) {
+    ensureCredentialsOrExit(creds);
+    const checkUrl = `${creds.baseUrl}/api/agent/connect?teamId=${encodeURIComponent(creds.teamId)}`;
+    const userAgent = `infigure-mcp-bridge/1.0.0 (Node.js ${process.version}; ${process.platform}; ${process.arch})`;
+    console.log(`URL:     ${creds.baseUrl}`);
+    console.log(`Team ID: ${creds.teamId}`);
+    try {
+        const response = await fetch(checkUrl, {
+            headers: {
+                "Authorization": `Bearer ${creds.token}`,
+                "Accept": "application/json",
+                "User-Agent": userAgent,
+            },
+        });
+        if (!response.ok) {
+            console.error(`Authentication failed: HTTP ${response.status} (${response.statusText})`);
+            process.exit(1);
+        }
+        const payload = (await response.json());
+        if (payload.authenticated) {
+            console.log("Authentication successful.");
+            if (payload.readiness) {
+                console.log(`Status:  ${payload.readiness.ok ? "Ready" : "Checks failing"}`);
+            }
+        }
+        else {
+            console.error("Authentication failed: Invalid token or unauthorized team membership.");
+            process.exit(1);
+        }
+    }
+    catch (err) {
+        console.error(`Connection error: ${err.message}`);
+        process.exit(1);
+    }
+}
+function resolveInstallTargets(client) {
+    const targets = [];
+    const normalized = client.toLowerCase().trim();
+    if (normalized === "claude-code" || normalized === "all") {
+        targets.push({
+            name: "Claude Code",
+            path: path.join(os.homedir(), ".claude.json"),
+            format: "json",
+        });
+    }
+    if (normalized === "claude-desktop" || normalized === "all") {
+        let desktopPath = "";
+        if (process.platform === "win32") {
+            desktopPath = process.env.APPDATA
+                ? path.join(process.env.APPDATA, "Claude", "claude_desktop_config.json")
+                : "";
+        }
+        else if (process.platform === "darwin") {
+            desktopPath = path.join(os.homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+        }
+        else {
+            desktopPath = path.join(os.homedir(), ".config", "Claude", "claude_desktop_config.json");
+        }
+        if (desktopPath) {
+            targets.push({
+                name: "Claude Desktop",
+                path: desktopPath,
+                format: "json",
+            });
+        }
+    }
+    if (normalized === "codex" || normalized === "all") {
+        targets.push({
+            name: "Codex",
+            path: path.join(os.homedir(), ".codex", "config.toml"),
+            format: "toml",
+        });
+    }
+    return targets;
+}
+async function runInstall(client) {
+    if (!client) {
+        console.error("Usage: infigure-mcp install [claude-code | claude-desktop | codex | all]");
+        process.exit(1);
+    }
+    const dummyConfig = {
+        command: "install",
+        installClient: client,
+        url: "",
+        token: "",
+        teamId: "",
+        verbose: false,
+        help: false,
+    };
+    const creds = resolveCredentials(dummyConfig);
+    ensureCredentialsOrExit(creds);
+    const targets = resolveInstallTargets(client);
+    if (targets.length === 0) {
+        console.error(`Error: Unknown target "${client}".`);
+        process.exit(1);
+    }
+    for (const target of targets) {
+        console.log(`Writing config to ${target.path}...`);
+        try {
+            fs.mkdirSync(path.dirname(target.path), { recursive: true });
+            if (target.format === "json") {
+                let configData = {};
+                if (fs.existsSync(target.path)) {
+                    try {
+                        configData = JSON.parse(fs.readFileSync(target.path, "utf8"));
+                    }
+                    catch (e) {
+                        console.error(`  Warning: Failed to parse ${target.path}: ${e}. Overwriting.`);
+                    }
+                }
+                if (!configData.mcpServers || typeof configData.mcpServers !== "object") {
+                    configData.mcpServers = {};
+                }
+                configData.mcpServers["infigure"] = {
+                    command: "npx",
+                    args: ["-y", "@infigure/mcp-bridge"],
+                    env: {
+                        INFIGURE_BASE_URL: creds.baseUrl,
+                        INFIGURE_TOKEN: creds.token,
+                        INFIGURE_TEAM_ID: creds.teamId,
+                    },
+                };
+                fs.writeFileSync(target.path, JSON.stringify(configData, null, 2) + "\n", "utf8");
+                console.log("  Registered successfully.");
+            }
+            else if (target.format === "toml") {
+                let content = "";
+                if (fs.existsSync(target.path)) {
+                    content = fs.readFileSync(target.path, "utf8");
+                }
+                const entry = `\n[mcp_servers.infigure]\n` +
+                    `command = "npx"\n` +
+                    `args = ["-y", "@infigure/mcp-bridge"]\n` +
+                    `[mcp_servers.infigure.env]\n` +
+                    `INFIGURE_BASE_URL = "${creds.baseUrl}"\n` +
+                    `INFIGURE_TOKEN = "${creds.token}"\n` +
+                    `INFIGURE_TEAM_ID = "${creds.teamId}"\n`;
+                if (content.includes("[mcp_servers.infigure]")) {
+                    console.log(`  Already registered.`);
+                }
+                else {
+                    fs.writeFileSync(target.path, content + entry, "utf8");
+                    console.log("  Registered successfully.");
+                }
+            }
+        }
+        catch (err) {
+            console.error(`  Error installing: ${err.message}`);
+        }
+    }
+}
+async function handleJsonRpc(payload, creds, cliConfig, userAgent) {
+    const mcpUrl = `${creds.baseUrl}/api/agent/mcp`;
+    if (payload.params &&
+        typeof payload.params === "object" &&
+        !Array.isArray(payload.params)) {
+        if (payload.params.teamId === undefined || payload.params.teamId === null) {
+            payload.params.teamId = creds.teamId;
+        }
+        if (payload.method === "tools/call") {
+            const args = payload.params.arguments;
+            if (args && typeof args === "object" && !Array.isArray(args)) {
+                if (args.teamId === undefined || args.teamId === null) {
+                    args.teamId = creds.teamId;
+                }
+            }
+        }
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 60000);
+    try {
+        const response = await fetch(mcpUrl, {
+            method: "POST",
+            headers: {
+                "Authorization": `Bearer ${creds.token}`,
+                "Content-Type": "application/json",
+                "Accept": "application/json",
+                "User-Agent": userAgent,
+            },
+            body: JSON.stringify(payload),
+            signal: controller.signal,
+        });
+        const responseText = await response.text();
+        if (!response.ok) {
+            try {
+                const parsed = JSON.parse(responseText);
+                if (parsed.error) {
+                    console.log(responseText.trim());
+                    return;
+                }
+            }
+            catch { }
+            const errResp = {
+                jsonrpc: "2.0",
+                id: payload.id ?? null,
+                error: {
+                    code: -32603,
+                    message: `HTTP error ${response.status}: ${response.statusText}`,
+                    data: { body: responseText },
+                },
+            };
+            console.log(JSON.stringify(errResp));
+            return;
+        }
+        console.log(responseText.trim());
+    }
+    catch (err) {
+        if (cliConfig.verbose) {
+            console.error(`[Infigure MCP] Connection error (id: ${payload.id}): ${err.message}`);
+        }
+        const isTimeout = err.name === "AbortError";
+        const errResp = {
+            jsonrpc: "2.0",
+            id: payload.id ?? null,
+            error: {
+                code: isTimeout ? -32000 : -32603,
+                message: isTimeout
+                    ? "Request timed out"
+                    : `Connection error: ${err.message}`,
+            },
+        };
+        console.log(JSON.stringify(errResp));
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}
+async function runServe(creds, cliConfig) {
+    ensureCredentialsOrExit(creds);
+    const mcpUrl = `${creds.baseUrl}/api/agent/mcp`;
+    const userAgent = `infigure-mcp-bridge/1.0.0 (Node.js ${process.version}; ${process.platform}; ${process.arch})`;
+    if (cliConfig.verbose) {
+        console.error(`[Infigure MCP] Proxying to ${mcpUrl}`);
+    }
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        terminal: false,
+    });
+    for await (const line of rl) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        let payload;
+        try {
+            payload = JSON.parse(trimmed);
+        }
+        catch (err) {
+            const errResp = {
+                jsonrpc: "2.0",
+                id: null,
+                error: {
+                    code: -32700,
+                    message: `Parse error: ${err.message}`,
+                },
+            };
+            console.log(JSON.stringify(errResp));
+            continue;
+        }
+        void handleJsonRpc(payload, creds, cliConfig, userAgent);
+    }
+}
+async function main() {
+    const cliConfig = parseArgs();
+    if (cliConfig.help) {
+        console.log(USAGE);
+        process.exit(0);
+    }
+    const creds = resolveCredentials(cliConfig);
+    switch (cliConfig.command) {
+        case "configure":
+            await runConfigure();
+            break;
+        case "whoami":
+            await runWhoAmI(creds);
+            break;
+        case "install":
+            await runInstall(cliConfig.installClient);
+            break;
+        case "serve":
+        default:
+            await runServe(creds, cliConfig);
+            break;
+    }
+}
+main().catch((err) => {
+    console.error("[Infigure MCP] Fatal error:", err);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@infigure/mcp-bridge",
+  "version": "1.0.0",
+  "description": "Local stdio-to-HTTP Model Context Protocol (MCP) bridge for Infigure.",
+  "main": "dist/index.js",
+  "type": "module",
+  "bin": {
+    "infigure-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "infigure",
+    "ai",
+    "agent"
+  ],
+  "author": "Infigure team",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^20.19.43",
+    "typescript": "^5.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}