@bigbrain-work/mcp-connect 1.2.2 → 1.3.0

package/src/proxy.js

@@ -1,5 +1,5 @@
-import { Server } from '@modelcontextprotocol/sdk/server/index.js'
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import {
   CallToolRequestSchema,
   GetPromptRequestSchema,
@@ -8,85 +8,86 @@ import {
   ListResourceTemplatesRequestSchema,
   ListToolsRequestSchema,
   ReadResourceRequestSchema,
-} from '@modelcontextprotocol/sdk/types.js'
+} 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
-}
+import { resolveAuthorization } from "./authorization.js";
+import { API_KEY_ENV, AUTH_URL, PACKAGE_VERSION } from "./constants.js";
+import { connectRemote } from "./remote-client.js";
 
 export async function runProxy({
   home,
   url,
+  authUrl = AUTH_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 authorization = await resolveAuthorization({
+    home,
+    platform,
+    env,
+    authUrl,
+  });
+  if (!authorization.token) {
+    throw new Error(
+      `未找到登录凭据，请先运行 shiliu login，或设置 ${API_KEY_ENV}`,
+    );
+  }
+  const remote = await connectRemote({ token: authorization.token, 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,
-    },
+    { name: "shiliu-ai-mcp-proxy", version: PACKAGE_VERSION },
     {
       capabilities,
-      instructions: 'Authenticated stdio bridge for the Shiliu AI remote MCP service.',
+      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)
-    ))
+    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)
-    ))
+    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)
-    ))
+    server.setRequestHandler(ListPromptsRequestSchema, (request) =>
+      remote.listPrompts(request.params),
+    );
+    server.setRequestHandler(GetPromptRequestSchema, (request) =>
+      remote.getPrompt(request.params),
+    );
   }
 
-  let closing = false
+  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)
+    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())
+    await server.connect(new StdioServerTransport());
   } catch (error) {
-    await shutdown()
-    throw error
+    await shutdown();
+    throw error;
   }
 }

package/src/remote-client.js

@@ -1,20 +1,37 @@
-import { Client } from '@modelcontextprotocol/sdk/client/index.js'
-import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js'
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 
-import { PACKAGE_VERSION } from './constants.js'
+import { PACKAGE_VERSION } from "./constants.js";
 
-export async function connectRemote({ apiKey, url }) {
+export async function connectRemote({ token, apiKey, url }) {
+  const authorizationToken = token || apiKey;
+  if (!authorizationToken) throw new Error("Missing authorization token");
   const client = new Client({
-    name: 'shiliu-ai-mcp-connect',
+    name: "shiliu-ai-cli",
     version: PACKAGE_VERSION,
-  })
+  });
   const transport = new StreamableHTTPClientTransport(new URL(url), {
     requestInit: {
       headers: {
-        Authorization: `Bearer ${apiKey}`,
+        Authorization: `Bearer ${authorizationToken}`,
       },
     },
-  })
-  await client.connect(transport)
-  return client
+  });
+  await client.connect(transport);
+  return client;
+}
+
+export async function readToolCatalog({
+  token,
+  apiKey,
+  url,
+  connect = connectRemote,
+}) {
+  const client = await connect({ token: token || apiKey, url });
+  try {
+    const result = await client.listTools();
+    return result.tools || [];
+  } finally {
+    await client.close();
+  }
 }

package/src/security.js

@@ -0,0 +1,63 @@
+import { AUTH_URL, MCP_URL } from "./constants.js";
+
+const LOOPBACK_HOSTS = new Set(["127.0.0.1", "localhost", "[::1]"]);
+const USER_CODE_PATTERN = /^[A-HJ-NP-Z2-9]{4}-[A-HJ-NP-Z2-9]{4}$/u;
+
+function normalizeEndpoint(value) {
+  const parsed = new URL(value);
+  if (parsed.username || parsed.password) {
+    throw new Error("服务地址不能包含用户名或密码");
+  }
+  if (parsed.hash) throw new Error("服务地址不能包含 URL 片段");
+  parsed.pathname = parsed.pathname.replace(/\/+$/u, "") || "/";
+  return parsed;
+}
+
+function isSameEndpoint(actual, expected) {
+  return (
+    actual.protocol === expected.protocol &&
+    actual.hostname === expected.hostname &&
+    actual.port === expected.port &&
+    actual.pathname === expected.pathname &&
+    actual.search === expected.search
+  );
+}
+
+function validateServiceUrl(value, expectedValue, label, { allowLocalhost }) {
+  let actual;
+  let expected;
+  try {
+    actual = normalizeEndpoint(value);
+    expected = normalizeEndpoint(expectedValue);
+  } catch (error) {
+    throw new Error(`${label}无效：${error.message}`);
+  }
+
+  if (isSameEndpoint(actual, expected)) return actual.toString();
+  if (
+    allowLocalhost &&
+    LOOPBACK_HOSTS.has(actual.hostname) &&
+    ["http:", "https:"].includes(actual.protocol)
+  ) {
+    return actual.toString();
+  }
+
+  throw new Error(
+    `${label}仅允许石榴 AI 正式地址；本机测试请使用回环地址并显式添加 --allow-localhost`,
+  );
+}
+
+export function validateMcpUrl(value, options = {}) {
+  return validateServiceUrl(value, MCP_URL, "MCP 地址", options);
+}
+
+export function validateAuthUrl(value, options = {}) {
+  return validateServiceUrl(value, AUTH_URL, "授权地址", options);
+}
+
+export function normalizeDeviceUserCode(value) {
+  if (typeof value !== "string" || !USER_CODE_PATTERN.test(value)) {
+    throw new Error("授权服务返回的登录会话编号格式无效");
+  }
+  return value;
+}

package/src/status.js

@@ -1,94 +1,153 @@
-import { readFile } from 'node:fs/promises'
-import path from 'node:path'
+import { readFile } from "node:fs/promises";
+import path from "node:path";
 
-import { API_KEY_ENV, MCP_URL, SERVER_NAME } from './constants.js'
-import { readPersistedApiKey } from './credentials.js'
+import { AUTH_URL, MCP_URL, PACKAGE_NAME, SERVER_NAME } from "./constants.js";
+import { resolveAuthorization } from "./authorization.js";
+import { readToolCatalog } from "./remote-client.js";
 
 async function readText(filePath) {
   try {
-    return await readFile(filePath, 'utf8')
+    return await readFile(filePath, "utf8");
   } catch (error) {
-    if (error.code === 'ENOENT') {
-      return ''
-    }
-    throw error
+    if (error.code === "ENOENT") return "";
+    throw error;
   }
 }
 
 async function hasServerConfig(filePath) {
-  const content = await readText(filePath)
-  return content.includes(SERVER_NAME) && content.includes(MCP_URL)
+  const content = await readText(filePath);
+  return (
+    content.includes(SERVER_NAME) &&
+    (content.includes(MCP_URL) || content.includes(PACKAGE_NAME))
+  );
 }
 
 export async function inspectLocalConfiguration(home) {
   return {
-    codex: await hasServerConfig(path.join(home, '.codex', 'config.toml')),
-    claude: await hasServerConfig(path.join(home, '.claude.json')),
-    cursor: await hasServerConfig(path.join(home, '.cursor', 'mcp.json')),
-  }
+    codex: await hasServerConfig(path.join(home, ".codex", "config.toml")),
+    claude: await hasServerConfig(path.join(home, ".claude.json")),
+    cursor: await hasServerConfig(path.join(home, ".cursor", "mcp.json")),
+  };
 }
 
-export async function probeMcp(apiKey, fetchImpl = fetch) {
-  if (!apiKey) {
+export async function probeMcp(
+  token,
+  { url = MCP_URL, readCatalog = readToolCatalog } = {},
+) {
+  if (!token) {
     return {
       ok: false,
-      detail: `${API_KEY_ENV} 尚未设置`,
-    }
+      detail: "尚未登录",
+      toolCount: 0,
+      tools: [],
+    };
   }
 
   try {
-    const response = await fetchImpl(MCP_URL, {
-      method: 'POST',
-      headers: {
-        Accept: 'application/json, text/event-stream',
-        Authorization: `Bearer ${apiKey}`,
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify({
-        jsonrpc: '2.0',
-        id: 1,
-        method: 'initialize',
-        params: {
-          protocolVersion: '2025-03-26',
-          capabilities: {},
-          clientInfo: {
-            name: 'bigbrain-work-mcp-connect',
-            version: '1.0.0',
-          },
-        },
-      }),
-      signal: AbortSignal.timeout(10000),
-    })
+    const tools = await readCatalog({ token, url });
     return {
-      ok: response.ok,
-      detail: response.ok ? `HTTP ${response.status}` : `HTTP ${response.status}，请检查 API Key`,
-    }
+      ok: true,
+      detail: `连接正常，tools/list 返回 ${tools.length} 个工具`,
+      toolCount: tools.length,
+      tools,
+    };
   } catch (error) {
     return {
       ok: false,
       detail: `连接失败：${error.message}`,
-    }
+      toolCount: 0,
+      tools: [],
+    };
   }
 }
 
 function mark(ok) {
-  return ok ? '✓' : '○'
+  return ok ? "✓" : "○";
 }
 
-export async function printStatus({ home, platform = process.platform, env = process.env } = {}) {
-  const apiKey = readPersistedApiKey({ platform, env, home })
-  const configs = await inspectLocalConfiguration(home)
-  const remote = await probeMcp(apiKey)
-
-  console.log(`API Key 环境变量  ${mark(Boolean(apiKey))} ${apiKey ? '已设置' : '未设置'}`)
-  console.log(`Codex 配置         ${mark(configs.codex)} ${configs.codex ? '已写入' : '未发现'}`)
-  console.log(`Claude Code 配置   ${mark(configs.claude)} ${configs.claude ? '已写入' : '未发现'}`)
-  console.log(`Cursor 配置        ${mark(configs.cursor)} ${configs.cursor ? '已写入' : '未发现'}`)
-  console.log(`石榴 AI MCP        ${mark(remote.ok)} ${remote.detail}`)
-
+export async function getStatus({
+  home,
+  platform = process.platform,
+  env = process.env,
+  url = MCP_URL,
+  authUrl = AUTH_URL,
+  readCatalog,
+  resolveAuth = resolveAuthorization,
+} = {}) {
+  const authorization = await resolveAuth({ home, platform, env, authUrl });
+  const configs = await inspectLocalConfiguration(home);
+  const remote = await probeMcp(authorization.token, { url, readCatalog });
   return {
-    apiKey: Boolean(apiKey),
+    credential: Boolean(authorization.token),
+    credentialSource: authorization.source,
     configs,
     remote,
+  };
+}
+
+export async function printStatus(options = {}) {
+  const result = await getStatus(options);
+  if (options.json) {
+    console.log(
+      JSON.stringify(
+        {
+          credential: result.credential,
+          credentialSource: result.credentialSource,
+          configs: result.configs,
+          remote: {
+            ok: result.remote.ok,
+            detail: result.remote.detail,
+            toolCount: result.remote.toolCount,
+          },
+        },
+        null,
+        2,
+      ),
+    );
+    return result;
+  }
+
+  console.log(
+    `登录凭据          ${mark(result.credential)} ${result.credential ? `已设置（${result.credentialSource}）` : "未设置"}`,
+  );
+  console.log(
+    `Codex 配置        ${mark(result.configs.codex)} ${result.configs.codex ? "已写入" : "未发现"}`,
+  );
+  console.log(
+    `Claude Code 配置  ${mark(result.configs.claude)} ${result.configs.claude ? "已写入" : "未发现"}`,
+  );
+  console.log(
+    `Cursor 配置       ${mark(result.configs.cursor)} ${result.configs.cursor ? "已写入" : "未发现"}`,
+  );
+  console.log(
+    `石榴 AI MCP       ${mark(result.remote.ok)} ${result.remote.detail}`,
+  );
+  return result;
+}
+
+export async function printTools({
+  home,
+  platform = process.platform,
+  env = process.env,
+  url = MCP_URL,
+  authUrl = AUTH_URL,
+  json = false,
+  readCatalog = readToolCatalog,
+  resolveAuth = resolveAuthorization,
+} = {}) {
+  const authorization = await resolveAuth({ home, platform, env, authUrl });
+  if (!authorization.token) throw new Error("尚未登录，请先运行 shiliu login");
+  const tools = await readCatalog({ token: authorization.token, url });
+
+  if (json) {
+    console.log(JSON.stringify({ count: tools.length, tools }, null, 2));
+    return tools;
+  }
+
+  console.log(`石榴 AI MCP 当前提供 ${tools.length} 个工具：`);
+  for (const tool of tools) {
+    const summary = tool.description ? ` — ${tool.description}` : "";
+    console.log(`- ${tool.name}${summary}`);
   }
+  return tools;
 }

package/src/token-store.js

@@ -0,0 +1,116 @@
+import {
+  KEYRING_ACCOUNT,
+  KEYRING_SERVICE,
+  PENDING_KEYRING_ACCOUNT,
+} from "./constants.js";
+
+function validateTokenSet(value) {
+  if (
+    !value ||
+    typeof value !== "object" ||
+    typeof value.accessToken !== "string" ||
+    typeof value.refreshToken !== "string" ||
+    typeof value.expiresAt !== "number"
+  ) {
+    throw new Error("本机凭据格式无效，请重新运行 shiliu login");
+  }
+  return value;
+}
+
+async function createSystemEntry(account) {
+  let module;
+  try {
+    module = await import("@napi-rs/keyring");
+  } catch (error) {
+    throw new Error(`无法加载系统凭据库：${error.message}`);
+  }
+  return new module.Entry(KEYRING_SERVICE, account);
+}
+
+async function defaultEntryFactory() {
+  return createSystemEntry(KEYRING_ACCOUNT);
+}
+
+async function defaultPendingEntryFactory() {
+  return createSystemEntry(PENDING_KEYRING_ACCOUNT);
+}
+
+export class TokenStore {
+  constructor({ entryFactory = defaultEntryFactory } = {}) {
+    this.entryFactory = entryFactory;
+  }
+
+  async save(tokenSet) {
+    const entry = await this.entryFactory();
+    await entry.setPassword(JSON.stringify(validateTokenSet(tokenSet)));
+  }
+
+  async load() {
+    const entry = await this.entryFactory();
+    try {
+      const serialized = await entry.getPassword();
+      if (!serialized) return null;
+      return validateTokenSet(JSON.parse(serialized));
+    } catch (error) {
+      if (this.isMissingEntry(error)) return null;
+      throw new Error(`无法读取系统凭据库：${error.message}`);
+    }
+  }
+
+  async clear() {
+    const entry = await this.entryFactory();
+    try {
+      await entry.deletePassword();
+    } catch (error) {
+      if (!this.isMissingEntry(error)) {
+        throw new Error(`无法清除系统凭据库：${error.message}`);
+      }
+    }
+  }
+
+  isMissingEntry(error) {
+    return /not found|no entry|no matching|credential.*missing/iu.test(
+      error?.message || "",
+    );
+  }
+}
+
+function validatePendingLogin(value) {
+  if (
+    !value ||
+    typeof value !== "object" ||
+    typeof value.sessionId !== "string" ||
+    typeof value.deviceCode !== "string" ||
+    typeof value.expiresAt !== "number" ||
+    typeof value.interval !== "number" ||
+    typeof value.authUrl !== "string" ||
+    (value.allowLocalhost !== undefined &&
+      typeof value.allowLocalhost !== "boolean")
+  ) {
+    throw new Error("待处理登录会话格式无效，请重新运行 shiliu login");
+  }
+  return value;
+}
+
+export class PendingLoginStore extends TokenStore {
+  constructor({ entryFactory = defaultPendingEntryFactory } = {}) {
+    super({ entryFactory });
+  }
+
+  async save(value) {
+    const entry = await this.entryFactory();
+    await entry.setPassword(JSON.stringify(validatePendingLogin(value)));
+  }
+
+  async load() {
+    const entry = await this.entryFactory();
+    try {
+      const serialized = await entry.getPassword();
+      if (!serialized) return null;
+      return validatePendingLogin(JSON.parse(serialized));
+    } catch (error) {
+      if (this.isMissingEntry(error)) return null;
+      throw new Error(`无法读取待处理登录会话：${error.message}`);
+    }
+  }
+}

package/src/updater.js

@@ -0,0 +1,59 @@
+import {
+  PACKAGE_NAME,
+  PACKAGE_VERSION,
+  REGISTRY_LATEST_URL,
+} from "./constants.js";
+
+function parseVersion(value) {
+  const match = String(value).match(
+    /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/u,
+  );
+  if (!match) return null;
+  return {
+    numbers: match.slice(1, 4).map(Number),
+    prerelease: match[4] || "",
+  };
+}
+
+export function compareVersions(left, right) {
+  const a = parseVersion(left);
+  const b = parseVersion(right);
+  if (!a || !b) return 0;
+  for (let index = 0; index < 3; index += 1) {
+    if (a.numbers[index] !== b.numbers[index]) {
+      return a.numbers[index] > b.numbers[index] ? 1 : -1;
+    }
+  }
+  if (a.prerelease === b.prerelease) return 0;
+  if (!a.prerelease) return 1;
+  if (!b.prerelease) return -1;
+  return a.prerelease.localeCompare(b.prerelease);
+}
+
+export async function checkForUpdates({ fetchImpl = fetch } = {}) {
+  const response = await fetchImpl(REGISTRY_LATEST_URL, {
+    headers: { Accept: "application/json" },
+    signal: AbortSignal.timeout(10000),
+  });
+  if (!response.ok)
+    throw new Error(`npm registry 返回 HTTP ${response.status}`);
+  const metadata = await response.json();
+  const latest = metadata.version;
+  if (!latest) throw new Error("npm registry 未返回版本号");
+  return {
+    current: PACKAGE_VERSION,
+    latest,
+    updateAvailable: compareVersions(latest, PACKAGE_VERSION) > 0,
+  };
+}
+
+export async function printUpdateStatus(options = {}) {
+  const result = await checkForUpdates(options);
+  if (result.updateAvailable) {
+    console.log(`发现新版本：${result.current} → ${result.latest}`);
+    console.log(`更新命令：npm install -g ${PACKAGE_NAME}@latest`);
+  } else {
+    console.log(`当前版本：${result.current}；npm latest：${result.latest}`);
+  }
+  return result;
+}