pinelabs-mcp 1.0.0

package/src/commands/proxy.js

@@ -0,0 +1,83 @@
+"use strict";
+
+const { spawn } = require("node:child_process");
+const { loadConfig } = require("../config.js");
+
+function log(message) {
+  process.stderr.write(`[pinelabs-mcp] ${message}\n`);
+}
+
+function startProxy() {
+  let config;
+  try {
+    config = loadConfig();
+  } catch (err) {
+    process.stderr.write(err.message + "\n");
+    process.exit(1);
+    return;
+  }
+
+  const { clientId, clientSecret, endpoint, debug } = config;
+
+  const maskedId =
+    clientId.length > 4
+      ? clientId.substring(0, 4) + "***"
+      : clientId.substring(0, 1) + "***";
+
+  log(`Pine Labs MCP Client v${require("../../package.json").version}`);
+  log(`Endpoint: ${endpoint}`);
+  log(`Client ID: ${maskedId}`);
+  log(`Transport: stdio <-> streamable-http`);
+
+  const mcpRemoteBin = require.resolve("mcp-remote/dist/proxy.js");
+
+  const args = [
+    mcpRemoteBin,
+    endpoint,
+    "--header",
+    `X-Client-Id:${clientId}`,
+    "--header",
+    `X-Client-Secret:${clientSecret}`,
+    "--transport",
+    "http-first",
+  ];
+
+  if (debug) {
+    args.push("--debug");
+  }
+
+  const child = spawn(process.execPath, args, {
+    stdio: ["pipe", "pipe", "pipe"],
+    env: { ...process.env },
+  });
+
+  process.stdin.pipe(child.stdin);
+  child.stdout.pipe(process.stdout);
+  child.stderr.pipe(process.stderr);
+
+  child.on("exit", (code, signal) => {
+    if (signal) {
+      log(`mcp-remote terminated by signal: ${signal}`);
+      process.exit(1);
+    }
+    process.exit(code || 0);
+  });
+
+  child.on("error", (err) => {
+    log(`Failed to start mcp-remote: ${err.message}`);
+    process.exit(1);
+  });
+
+  const signals = ["SIGINT", "SIGTERM", "SIGHUP"];
+  for (const sig of signals) {
+    process.on(sig, () => {
+      child.kill(sig);
+    });
+  }
+
+  process.stdin.on("end", () => {
+    child.kill("SIGTERM");
+  });
+}
+
+module.exports = { startProxy };

package/src/commands/setup.js

@@ -0,0 +1,241 @@
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+const { loadStoredConfig } = require("../config-store.js");
+
+const SUPPORTED_CLIENTS = [
+  "claude-desktop",
+  "cursor",
+  "vscode",
+  "windsurf",
+  "opencode",
+  "copilot",
+  "codex",
+];
+
+function log(message) {
+  process.stderr.write(`${message}\n`);
+}
+
+function _getClientConfigPath(client) {
+  const home = os.homedir();
+  const platform = os.platform();
+
+  switch (client) {
+    case "claude-desktop":
+      if (platform === "darwin") {
+        return path.join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
+      }
+      if (platform === "win32") {
+        return path.join(process.env.APPDATA || path.join(home, "AppData", "Roaming"), "Claude", "claude_desktop_config.json");
+      }
+      return path.join(home, ".config", "claude", "claude_desktop_config.json");
+
+    case "cursor":
+      return path.join(home, ".cursor", "mcp.json");
+
+    case "vscode":
+      return path.join(process.cwd(), ".vscode", "mcp.json");
+
+    case "windsurf":
+      return path.join(home, ".codeium", "windsurf", "mcp_config.json");
+
+    case "opencode":
+      return path.join(process.cwd(), ".opencode", "config.json");
+
+    case "copilot":
+      return path.join(home, ".copilot", "mcp-config.json");
+
+    case "codex":
+      return path.join(home, ".codex", "config.toml");
+
+    default:
+      return "";
+  }
+}
+
+/**
+ * Resolve the absolute path to bin/cli.js using forward slashes.
+ */
+function _getLocalCliPath() {
+  return path.resolve(__dirname, "..", "..", "bin", "cli.js").replace(/\\/g, "/");
+}
+
+function _buildMcpConfig(client, config, options = {}) {
+  let serverEntry;
+
+  if (options.local) {
+    serverEntry = {
+      command: "node",
+      args: [_getLocalCliPath()],
+      env: {
+        PINELABS_CLIENT_ID: config.client_id,
+        PINELABS_CLIENT_SECRET: config.client_secret,
+      },
+    };
+  } else {
+    serverEntry = {
+      command: "npx",
+      args: ["-y", "pinelabs-mcp"],
+      env: {
+        PINELABS_CLIENT_ID: config.client_id,
+        PINELABS_CLIENT_SECRET: config.client_secret,
+      },
+    };
+  }
+
+  if (config.environment && config.environment !== "prod") {
+    serverEntry.env.PINELABS_ENV = config.environment;
+  }
+
+  if (client === "vscode") {
+    return { servers: { pinelabs: serverEntry } };
+  }
+
+  return { mcpServers: { pinelabs: serverEntry } };
+}
+
+/**
+ * Build TOML string for Codex CLI config.
+ * Codex uses ~/.codex/config.toml with [mcp_servers.<name>] tables.
+ */
+function _buildCodexToml(config, options = {}) {
+  const lines = [];
+  lines.push("[mcp_servers.pinelabs]");
+  if (options.local) {
+    lines.push('command = "node"');
+    lines.push(`args = ["${_getLocalCliPath()}"]`);
+  } else {
+    lines.push('command = "npx"');
+    lines.push('args = ["-y", "pinelabs-mcp"]');
+  }
+  lines.push("");
+  lines.push("[mcp_servers.pinelabs.env]");
+  lines.push(`PINELABS_CLIENT_ID = "${config.client_id}"`);
+  lines.push(`PINELABS_CLIENT_SECRET = "${config.client_secret}"`);
+  if (config.environment && config.environment !== "prod") {
+    lines.push(`PINELABS_ENV = "${config.environment}"`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+
+/**
+ * Merge pinelabs MCP server into existing Codex TOML content.
+ * If [mcp_servers.pinelabs] already exists, replace the entire section.
+ * Otherwise, append the new section at the end.
+ */
+function _mergeCodexToml(existingToml, newToml) {
+  // Match the pinelabs section: from [mcp_servers.pinelabs] to the next
+  // top-level section header or end of file
+  const sectionPattern = /\[mcp_servers\.pinelabs\][\s\S]*?(?=\n\[(?!mcp_servers\.pinelabs\.)|$)/;
+  if (sectionPattern.test(existingToml)) {
+    // Replace existing pinelabs section
+    return existingToml.replace(sectionPattern, newToml.trimEnd()).trimEnd() + "\n";
+  }
+  // Append new section
+  const separator = existingToml.endsWith("\n") ? "\n" : "\n\n";
+  return existingToml + separator + newToml;
+}
+
+function mergeConfig(existing, newConfig, client) {
+  const key = client === "vscode" ? "servers" : "mcpServers";
+  const merged = { ...existing };
+  merged[key] = { ...(existing[key] || {}), ...(newConfig[key] || {}) };
+  return merged;
+}
+
+async function setup(client, flags) {
+  if (!client || !SUPPORTED_CLIENTS.includes(client)) {
+    log(`\n  Error: Unknown client '${client || "(none)"}'.`);
+    log(`  Supported clients: ${SUPPORTED_CLIENTS.join(", ")}\n`);
+    process.exit(1);
+    return;
+  }
+
+  const storedConfig = loadStoredConfig();
+  if (!storedConfig || !storedConfig.client_id || !storedConfig.client_secret) {
+    log("\n  Error: No credentials configured.");
+    log("  Run `pinelabs-mcp configure` first.\n");
+    process.exit(1);
+    return;
+  }
+
+  // Codex uses TOML format — handle separately
+  if (client === "codex") {
+    const tomlContent = _buildCodexToml(storedConfig, { local: !!flags.local });
+
+    if (flags.print) {
+      process.stdout.write(tomlContent);
+      return;
+    }
+
+    const configPath = _getClientConfigPath(client);
+
+    let finalContent = tomlContent;
+    if (fs.existsSync(configPath)) {
+      try {
+        const existing = fs.readFileSync(configPath, "utf-8");
+        finalContent = _mergeCodexToml(existing, tomlContent);
+
+        const backupPath = configPath + ".bak";
+        fs.copyFileSync(configPath, backupPath);
+        log(`\n  Backup created: ${backupPath}`);
+      } catch {
+        // If we can't read existing, just overwrite
+      }
+    }
+
+    const dir = path.dirname(configPath);
+    fs.mkdirSync(dir, { recursive: true });
+
+    fs.writeFileSync(configPath, finalContent);
+
+    log(`\n  Pine Labs MCP configured for ${client}`);
+    log(`  Config written to: ${configPath}`);
+    log(`\n  Restart ${client} to start using Pine Labs tools.\n`);
+    return;
+  }
+
+  // All other clients use JSON format
+  const mcpConfig = _buildMcpConfig(client, storedConfig, { local: !!flags.local });
+
+  if (flags.print) {
+    process.stdout.write(JSON.stringify(mcpConfig, null, 2) + "\n");
+    return;
+  }
+
+  const configPath = _getClientConfigPath(client);
+  if (!configPath) {
+    log(`\n  Error: Cannot determine config path for '${client}'.\n`);
+    process.exit(1);
+    return;
+  }
+
+  let finalConfig = mcpConfig;
+  if (fs.existsSync(configPath)) {
+    try {
+      const existing = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+      finalConfig = mergeConfig(existing, mcpConfig, client);
+
+      const backupPath = configPath + ".bak";
+      fs.copyFileSync(configPath, backupPath);
+      log(`\n  Backup created: ${backupPath}`);
+    } catch {
+      // If we can't read/parse existing, just overwrite
+    }
+  }
+
+  const dir = path.dirname(configPath);
+  fs.mkdirSync(dir, { recursive: true });
+
+  fs.writeFileSync(configPath, JSON.stringify(finalConfig, null, 2) + "\n");
+
+  log(`\n  Pine Labs MCP configured for ${client}`);
+  log(`  Config written to: ${configPath}`);
+  log(`\n  Restart ${client} to start using Pine Labs tools.\n`);
+}
+
+module.exports = { setup, _buildMcpConfig, _buildCodexToml, _mergeCodexToml, _getClientConfigPath, _getLocalCliPath, mergeConfig, SUPPORTED_CLIENTS };

package/src/commands/status.js

@@ -0,0 +1,58 @@
+"use strict";
+
+const { loadStoredConfig, getConfigPath } = require("../config-store.js");
+const { ENDPOINTS } = require("../config.js");
+
+function log(message) {
+  process.stderr.write(`${message}\n`);
+}
+
+function maskId(id) {
+  if (!id) return "(not set)";
+  if (id.length > 4) return id.substring(0, 4) + "***";
+  return id.substring(0, 1) + "***";
+}
+
+function maskSecret(secret) {
+  if (!secret) return "(not set)";
+  return "••••••••••••••••";
+}
+
+function resolveEndpoint(config) {
+  if (config.endpoint) return config.endpoint;
+  const env = config.environment || "prod";
+  return ENDPOINTS[env] || ENDPOINTS.prod;
+}
+
+function showStatus() {
+  const configPath = getConfigPath();
+  const config = loadStoredConfig();
+
+  log("\n  Pine Labs MCP Configuration");
+  log("  ───────────────────────────");
+
+  if (!config) {
+    log(`  Config file:      ${configPath} (not found)`);
+    log("\n  No configuration found. Run `pinelabs-mcp configure` to set up.\n");
+    return;
+  }
+
+  const endpoint = resolveEndpoint(config);
+
+  log(`  Config file:      ${configPath}`);
+  log(`  Client ID:        ${maskId(config.client_id)}`);
+  log(`  Client Secret:    ${maskSecret(config.client_secret)}`);
+  log(`  Environment:      ${config.environment || "prod"}`);
+  log(`  Endpoint:         ${endpoint}`);
+
+  try {
+    const version = require("../../package.json").version;
+    log(`  Package version:  ${version}`);
+  } catch {
+    // ignore
+  }
+
+  log("");
+}
+
+module.exports = { showStatus };

package/src/commands/test.js

@@ -0,0 +1,118 @@
+"use strict";
+
+const https = require("node:https");
+const http = require("node:http");
+const { loadStoredConfig, getConfigPath } = require("../config-store.js");
+const { ENDPOINTS } = require("../config.js");
+
+function log(message) {
+  process.stderr.write(`${message}\n`);
+}
+
+function maskId(id) {
+  if (!id) return "(not set)";
+  if (id.length > 4) return id.substring(0, 4) + "***";
+  return id.substring(0, 1) + "***";
+}
+
+function resolveEndpoint(config) {
+  if (config.endpoint) return config.endpoint;
+  const env = config.environment || "prod";
+  return ENDPOINTS[env] || ENDPOINTS.prod;
+}
+
+function probeEndpoint(endpoint, clientId, clientSecret) {
+  return new Promise((resolve) => {
+    const healthUrl = endpoint.replace(/\/mcp\/?$/, "/health");
+    const url = new URL(healthUrl);
+    const client = url.protocol === "https:" ? https : http;
+
+    const req = client.request(
+      {
+        hostname: url.hostname,
+        port: url.port || (url.protocol === "https:" ? 443 : 80),
+        path: url.pathname,
+        method: "GET",
+        headers: {
+          "X-Client-Id": clientId,
+          "X-Client-Secret": clientSecret,
+        },
+        timeout: 10000,
+      },
+      (res) => {
+        res.resume();
+        resolve({ status: res.statusCode, ok: res.statusCode >= 200 && res.statusCode < 400 });
+      }
+    );
+
+    req.on("error", () => resolve({ status: 0, ok: false }));
+    req.on("timeout", () => {
+      req.destroy();
+      resolve({ status: 0, ok: false });
+    });
+    req.end();
+  });
+}
+
+async function testConnection() {
+  log("\n  Pine Labs MCP Connection Test");
+  log("  ─────────────────────────────");
+
+  const configPath = getConfigPath();
+  const config = loadStoredConfig();
+
+  if (!config) {
+    log(`  Config file:  ${configPath} (not found)`);
+    log("\n  No configuration found. Run `pinelabs-mcp configure` first.\n");
+    process.exit(1);
+    return;
+  }
+
+  log(`  Config file:  ${configPath}`);
+
+  if (!config.client_id) {
+    log("  Client ID:    (not set)");
+    log("\n  Client ID is missing. Run `pinelabs-mcp configure` to set it.\n");
+    process.exit(1);
+    return;
+  }
+
+  log(`  Client ID:    ${maskId(config.client_id)}`);
+
+  if (!config.client_secret) {
+    log("  Client Secret: (not set)");
+    log("\n  Client Secret is missing. Run `pinelabs-mcp configure` to set it.\n");
+    process.exit(1);
+    return;
+  }
+
+  const endpoint = resolveEndpoint(config);
+  log(`  Environment:  ${config.environment || "prod"}`);
+  log(`  Endpoint:     ${endpoint}`);
+
+  log("\n  Testing connectivity...");
+
+  const result = await probeEndpoint(endpoint, config.client_id, config.client_secret);
+
+  if (result.ok) {
+    log(`  Server reachable:    (HTTP ${result.status})`);
+    log("\n  Connection test passed. You're ready to go!\n");
+  } else if (result.status === 401 || result.status === 403) {
+    log("  Server reachable:    yes");
+    log(`  Authentication:      failed (HTTP ${result.status})`);
+    log("\n  Authentication failed. Verify your Client ID and Secret.\n");
+    process.exit(1);
+  } else if (result.status > 0) {
+    log("  Server reachable:    yes");
+    log(`  Server response:     HTTP ${result.status}`);
+    log("\n  Server is reachable but returned an unexpected status.\n");
+    process.exit(1);
+  } else {
+    log("  Server reachable:    no");
+    log(`\n  Cannot reach ${endpoint}`);
+    log("  Check your network connection and try again.\n");
+    process.exit(1);
+  }
+}
+
+module.exports = { testConnection };

package/src/config-store.js

@@ -0,0 +1,53 @@
+"use strict";
+
+/**
+ * Persistent configuration store for pinelabs-mcp.
+ *
+ * Stores credentials and settings in ~/.pinelabs-mcp/config.json.
+ * Provides read/write with automatic directory creation and
+ * file permission hardening on Unix systems.
+ */
+
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+
+const CONFIG_DIR_NAME = ".pinelabs-mcp";
+const CONFIG_FILE_NAME = "config.json";
+
+let _configDirOverride = null;
+
+function _setConfigDir(dir) {
+  _configDirOverride = dir;
+}
+
+function getConfigDir() {
+  if (_configDirOverride) return _configDirOverride;
+  if (process.env.PINELABS_MCP_CONFIG_DIR) return process.env.PINELABS_MCP_CONFIG_DIR;
+  return path.join(os.homedir(), CONFIG_DIR_NAME);
+}
+
+function getConfigPath() {
+  return path.join(getConfigDir(), CONFIG_FILE_NAME);
+}
+
+function loadStoredConfig() {
+  const configPath = getConfigPath();
+  try {
+    const raw = fs.readFileSync(configPath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+function saveConfig(data) {
+  const dir = getConfigDir();
+  fs.mkdirSync(dir, { recursive: true });
+
+  const configPath = getConfigPath();
+  const content = JSON.stringify(data, null, 2) + "\n";
+  fs.writeFileSync(configPath, content, { mode: 0o600 });
+}
+
+module.exports = { loadStoredConfig, saveConfig, getConfigDir, getConfigPath, _setConfigDir };

package/src/config.js

@@ -0,0 +1,90 @@
+"use strict";
+
+/**
+ * Configuration module for pinelabs-mcp.
+ *
+ * Reads credentials and endpoint configuration from environment variables.
+ * Validates that required credentials are present and resolves the correct
+ * MCP server endpoint based on the environment (prod/uat).
+ */
+
+const ENDPOINTS = {
+  prod: "https://mcp.pluralpay.in/mcp",
+  uat: "https://pluralai.v2.pinepg.in/mcp",
+};
+
+/**
+ * Parse and validate configuration from environment variables.
+ *
+ * @returns {{ clientId: string, clientSecret: string, endpoint: string, debug: boolean }}
+ * @throws {Error} If required credentials are missing.
+ */
+function loadConfig() {
+  let clientId = process.env.PINELABS_CLIENT_ID || "";
+  let clientSecret = process.env.PINELABS_CLIENT_SECRET || "";
+  let env = (process.env.PINELABS_ENV || "").toLowerCase();
+  const endpointOverride = process.env.PINELABS_MCP_ENDPOINT || "";
+  const debug =
+    process.env.DEBUG === "true" || process.env.DEBUG === "1" || false;
+
+  // Fall back to stored config file if env vars not set
+  if (!clientId || !clientSecret) {
+    try {
+      const { loadStoredConfig } = require("./config-store.js");
+      const stored = loadStoredConfig();
+      if (stored) {
+        if (!clientId) clientId = stored.client_id || "";
+        if (!clientSecret) clientSecret = stored.client_secret || "";
+        if (!env) env = (stored.environment || "prod").toLowerCase();
+      }
+    } catch {
+      // config-store not available, skip
+    }
+  }
+
+  if (!env) env = "prod";
+
+  const errors = [];
+
+  if (!clientId) {
+    errors.push("PINELABS_CLIENT_ID environment variable is required.");
+  }
+
+  if (!clientSecret) {
+    errors.push("PINELABS_CLIENT_SECRET environment variable is required.");
+  }
+
+  if (errors.length > 0) {
+    const message = [
+      "Error: Missing required credentials.\n",
+      ...errors.map((e) => `  - ${e}`),
+      "",
+      "Configure your MCP client with:",
+      '  "env": {',
+      '    "PINELABS_CLIENT_ID": "your_client_id",',
+      '    "PINELABS_CLIENT_SECRET": "your_client_secret"',
+      "  }",
+      "",
+      "Or run: pinelabs-mcp configure --client-id=X --client-secret=Y",
+      "",
+      "Get your credentials from the Pine Labs developer portal.",
+    ].join("\n");
+
+    throw new Error(message);
+  }
+
+  let endpoint;
+  if (endpointOverride) {
+    endpoint = endpointOverride;
+  } else if (env === "uat") {
+    endpoint = ENDPOINTS.uat;
+  } else if (env === "prod") {
+    endpoint = ENDPOINTS.prod;
+  } else {
+    endpoint = ENDPOINTS.prod;
+  }
+
+  return { clientId, clientSecret, endpoint, debug };
+}
+
+module.exports = { loadConfig, ENDPOINTS };

package/src/utils/args.js

@@ -0,0 +1,37 @@
+"use strict";
+
+/**
+ * Minimal argument parser. Zero dependencies.
+ *
+ * Parses process.argv.slice(2) style arrays into:
+ *   { command, positional, flags }
+ */
+
+function parseArgs(argv) {
+  const result = { command: null, positional: [], flags: {} };
+
+  let commandParsed = false;
+
+  for (const arg of argv) {
+    if (arg.startsWith("--")) {
+      const eqIdx = arg.indexOf("=");
+      if (eqIdx !== -1) {
+        const key = arg.substring(2, eqIdx);
+        const value = arg.substring(eqIdx + 1);
+        result.flags[key] = value;
+      } else {
+        const key = arg.substring(2);
+        result.flags[key] = true;
+      }
+    } else if (!commandParsed) {
+      result.command = arg;
+      commandParsed = true;
+    } else {
+      result.positional.push(arg);
+    }
+  }
+
+  return result;
+}
+
+module.exports = { parseArgs };