@bigbrain-work/mcp-connect 1.2.0 → 1.2.2

package/README.md

@@ -29,7 +29,13 @@ npx -y @bigbrain-work/mcp-connect --agent openclaw
 npx -y @bigbrain-work/mcp-connect --agent workbuddy
 ```
 
-对于尚未内置配置适配器的 Agent，安装器不会修改未知配置文件，而是输出石榴 AI 的通用 HTTP MCP 地址和认证方式。
+对于尚未内置配置适配器的 Agent，安装器不会猜测其私有配置文件，而是输出一份标准 stdio MCP 配置。该配置统一运行：
+
+```bash
+npx -y @bigbrain-work/mcp-connect proxy
+```
+
+桥接器从本机安全存储读取 `SHILIU_AI_API_KEY`，再连接远程 HTTP MCP。这样 WorkBuddy、OpenClaw 以及后续其他支持 stdio MCP 的 Agent 不需要分别开发认证头适配器。支持远程 HTTP MCP 和自定义认证头的客户端仍可直接连接服务地址。
 
 安装器会隐藏输入 API Key。配置完成后，重启对应客户端并检查连接：
 
@@ -46,6 +52,7 @@ npx -y @bigbrain-work/mcp-connect status
 - Windows 上，安装器通过标准输入将 API Key 写入当前用户环境变量，避免进入终端历史和子进程命令行。
 - macOS/Linux 上，API Key 保存在权限为 `0600` 的 `~/.config/shiliu-ai/env`，并由用户登录配置加载。
 - `status` 命令只显示“已设置/未设置”，不会输出 API Key。
+- 通用 `proxy` 的 stdout 只承载 MCP 协议数据，不会输出 API Key。
 
 ## 服务信息
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bigbrain-work/mcp-connect",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "石榴 AI MCP 智能配置工具，支持自动检测、通用 HTTP MCP 接入和本地 AI 剪辑工具安装。",
   "type": "module",
   "bin": {
@@ -28,5 +28,9 @@
   "publishConfig": {
     "access": "public"
   },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "1.29.0",
+    "zod": "^3.25.0"
+  },
   "license": "UNLICENSED"
 }

package/src/arguments.js

@@ -17,6 +17,9 @@ export function parseCliArguments(args) {
       home: {
         type: 'string',
       },
+      url: {
+        type: 'string',
+      },
       help: {
         type: 'boolean',
         short: 'h',
@@ -31,7 +34,7 @@ export function parseCliArguments(args) {
   })
 
   const command = parsed.positionals[0] || 'install'
-  if (!['install', 'status'].includes(command)) {
+  if (!['install', 'proxy', 'status'].includes(command)) {
     throw new Error(`不支持的命令：${command}`)
   }
 
@@ -45,6 +48,7 @@ export function parseCliArguments(args) {
     agent,
     dryRun: parsed.values['dry-run'],
     home: parsed.values.home,
+    url: parsed.values.url,
     help: parsed.values.help,
     version: parsed.values.version,
   }

package/src/cli.js

@@ -13,6 +13,7 @@ import {
   SUPPORTED_AGENTS,
 } from './constants.js'
 import { persistApiKey, resolveApiKey } from './credentials.js'
+import { runProxy } from './proxy.js'
 import { printStatus } from './status.js'
 
 function printHelp() {
@@ -21,12 +22,14 @@ function printHelp() {
 用法：
   mcp-connect
   mcp-connect --agent <name>
+  mcp-connect proxy
   mcp-connect status
 
 选项：
   -a, --agent <name>  配置指定客户端
       --dry-run       只显示将执行的操作
       --home <path>   指定用户目录（主要用于测试）
+      --url <url>     proxy 使用的远程 MCP 地址
   -h, --help          显示帮助
   -v, --version       显示版本
 
@@ -36,15 +39,36 @@ function printHelp() {
 
 智能配置：
   不指定 --agent 时，自动检测并配置已安装的 ${SUPPORTED_AGENTS.join('、')}。
-  其他 Agent 名称也可传入；未内置适配器时会输出通用 HTTP MCP 配置。`)
+  其他 Agent 名称也可传入；未内置适配器时会输出通用 stdio MCP 配置。
+  stdio 代理会从本机安全存储读取 API Key，再转发到远程 HTTP MCP。`)
+}
+
+export function stdioProxyDefinition(platform = process.platform) {
+  if (platform === 'win32') {
+    return {
+      command: 'cmd',
+      args: ['/d', '/s', '/c', 'npx', '-y', PACKAGE_NAME, 'proxy'],
+    }
+  }
+  return {
+    command: 'npx',
+    args: ['-y', PACKAGE_NAME, 'proxy'],
+  }
 }
 
 function printGenericInstructions(agent, { dryRun = false } = {}) {
-  console.log(`暂未内置 ${agent} 的自动配置适配器，请在该 Agent 中添加远程 HTTP MCP：
+  const proxy = stdioProxyDefinition()
+  const config = {
+    mcpServers: {
+      [SERVER_NAME]: proxy,
+    },
+  }
+  console.log(`暂未内置 ${agent} 的自动配置适配器。请在该 Agent 中添加下面这份标准 stdio MCP 配置：
+
+${JSON.stringify(config, null, 2)}
 
-名称：${SERVER_NAME}
-地址：${MCP_URL}
-认证头：Authorization: Bearer <你的石榴 AI API Key>
+该命令会在本机启动通用桥接器，由桥接器连接：${MCP_URL}
+Agent 配置中不需要填写 Authorization 请求头，也不保存真实 API Key。
 
 ${dryRun ? `演练模式未保存 API Key；正式运行时会安全保存到 ${API_KEY_ENV}。` : `API Key 已安全保存到 ${API_KEY_ENV}。`}请勿将真实 API Key 写入项目代码或提交到 Git。`)
 }
@@ -61,6 +85,10 @@ export async function runCli(argv = process.argv.slice(2)) {
   }
 
   const home = path.resolve(options.home || os.homedir())
+  if (options.command === 'proxy') {
+    await runProxy({ home, url: options.url || MCP_URL })
+    return
+  }
   if (options.command === 'status') {
     const result = await printStatus({ home })
     if (!result.remote.ok) {

package/src/configurators.js

@@ -1,3 +1,4 @@
+import { existsSync } from 'node:fs'
 import { mkdir, readFile, rename, writeFile } from 'node:fs/promises'
 import path from 'node:path'
 import { spawnSync } from 'node:child_process'
@@ -42,13 +43,65 @@ function commandText(command, args) {
   )).join(' ')
 }
 
+export function commandInvocation(command, args, {
+  platform = process.platform,
+  env = process.env,
+  fileExists = existsSync,
+  nodeExecutable = process.execPath,
+} = {}) {
+  if (platform !== 'win32') {
+    return { command, args }
+  }
+
+  const searchPath = env.PATH || env.Path || ''
+  const npmDirectory = searchPath
+    .split(';')
+    .map((entry) => entry.trim().replace(/^"|"$/gu, ''))
+    .filter(Boolean)
+    .find((entry) => fileExists(path.join(entry, `${command}.cmd`)))
+
+  if (!npmDirectory) {
+    return { command, args }
+  }
+
+  if (command === 'claude') {
+    const executable = path.join(
+      npmDirectory,
+      'node_modules',
+      '@anthropic-ai',
+      'claude-code',
+      'bin',
+      'claude.exe',
+    )
+    if (fileExists(executable)) {
+      return { command: executable, args }
+    }
+  }
+  if (command === 'codex') {
+    const script = path.join(
+      npmDirectory,
+      'node_modules',
+      '@openai',
+      'codex',
+      'bin',
+      'codex.js',
+    )
+    if (fileExists(script)) {
+      return { command: nodeExecutable, args: [script, ...args] }
+    }
+  }
+
+  return { command, args }
+}
+
 function execute(command, args, { dryRun = false } = {}) {
   if (dryRun) {
     console.log(`[dry-run] ${commandText(command, args)}`)
     return
   }
 
-  const result = spawnSync(command, args, {
+  const invocation = commandInvocation(command, args)
+  const result = spawnSync(invocation.command, invocation.args, {
     encoding: 'utf8',
     windowsHide: true,
     shell: false,

package/src/constants.js

@@ -1,5 +1,5 @@
 export const PACKAGE_NAME = '@bigbrain-work/mcp-connect'
-export const PACKAGE_VERSION = '1.2.0'
+export const PACKAGE_VERSION = '1.2.2'
 export const SERVER_NAME = 'shiliu_mcp'
 export const MCP_URL = 'https://api.bigbrain.work/shiliu/mcp'
 export const API_KEY_ENV = 'SHILIU_AI_API_KEY'

package/src/proxy.js

@@ -0,0 +1,92 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js'
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
+import {
+  CallToolRequestSchema,
+  GetPromptRequestSchema,
+  ListPromptsRequestSchema,
+  ListResourcesRequestSchema,
+  ListResourceTemplatesRequestSchema,
+  ListToolsRequestSchema,
+  ReadResourceRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js'
+
+import { API_KEY_ENV, PACKAGE_VERSION } from './constants.js'
+import { readPersistedApiKey } from './credentials.js'
+import { connectRemote } from './remote-client.js'
+
+function resolveProxyApiKey({ home, platform = process.platform, env = process.env }) {
+  const apiKey = readPersistedApiKey({ home, platform, env })?.trim()
+  if (!apiKey) {
+    throw new Error(`未找到 API Key，请先运行 mcp-connect 安装，或设置 ${API_KEY_ENV}`)
+  }
+  return apiKey
+}
+
+export async function runProxy({
+  home,
+  url,
+  platform = process.platform,
+  env = process.env,
+} = {}) {
+  const apiKey = resolveProxyApiKey({ home, platform, env })
+  const remote = await connectRemote({ apiKey, url })
+  const remoteCapabilities = remote.getServerCapabilities() ?? {}
+  const capabilities = {}
+  if (remoteCapabilities.tools) capabilities.tools = {}
+  if (remoteCapabilities.resources) capabilities.resources = {}
+  if (remoteCapabilities.prompts) capabilities.prompts = {}
+
+  const server = new Server(
+    {
+      name: 'shiliu-ai-mcp-proxy',
+      version: PACKAGE_VERSION,
+    },
+    {
+      capabilities,
+      instructions: 'Authenticated stdio bridge for the Shiliu AI remote MCP service.',
+    },
+  )
+
+  if (remoteCapabilities.tools) {
+    server.setRequestHandler(ListToolsRequestSchema, (request) => (
+      remote.listTools(request.params)
+    ))
+    server.setRequestHandler(CallToolRequestSchema, (request) => (
+      remote.callTool(request.params)
+    ))
+  }
+  if (remoteCapabilities.resources) {
+    server.setRequestHandler(ListResourcesRequestSchema, (request) => (
+      remote.listResources(request.params)
+    ))
+    server.setRequestHandler(ListResourceTemplatesRequestSchema, (request) => (
+      remote.listResourceTemplates(request.params)
+    ))
+    server.setRequestHandler(ReadResourceRequestSchema, (request) => (
+      remote.readResource(request.params)
+    ))
+  }
+  if (remoteCapabilities.prompts) {
+    server.setRequestHandler(ListPromptsRequestSchema, (request) => (
+      remote.listPrompts(request.params)
+    ))
+    server.setRequestHandler(GetPromptRequestSchema, (request) => (
+      remote.getPrompt(request.params)
+    ))
+  }
+
+  let closing = false
+  const shutdown = async () => {
+    if (closing) return
+    closing = true
+    await Promise.allSettled([server.close(), remote.close()])
+  }
+  process.once('SIGINT', shutdown)
+  process.once('SIGTERM', shutdown)
+  try {
+    await server.connect(new StdioServerTransport())
+  } catch (error) {
+    await shutdown()
+    throw error
+  }
+}

package/src/remote-client.js

@@ -0,0 +1,20 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js'
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js'
+
+import { PACKAGE_VERSION } from './constants.js'
+
+export async function connectRemote({ apiKey, url }) {
+  const client = new Client({
+    name: 'shiliu-ai-mcp-connect',
+    version: PACKAGE_VERSION,
+  })
+  const transport = new StreamableHTTPClientTransport(new URL(url), {
+    requestInit: {
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+      },
+    },
+  })
+  await client.connect(transport)
+  return client
+}