@bigbrain-work/mcp-connect 1.2.2 → 1.3.1

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,88 @@ 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,
+  tokenStore,
 } = {}) {
-  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,
+    tokenStore,
+  });
+  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/skill-refresh.js

@@ -0,0 +1,202 @@
+import { spawnSync } from "node:child_process";
+import {
+  mkdir,
+  open,
+  readFile,
+  stat,
+  unlink,
+  writeFile,
+} from "node:fs/promises";
+import path from "node:path";
+
+export const SKILL_REFRESH_INTERVAL_MS = 24 * 60 * 60 * 1000;
+export const SHILIU_SKILL_NAME = "shiliu-ai-mcp";
+const STALE_LOCK_MS = 15 * 60 * 1000;
+
+function stateFile(home) {
+  return path.join(home, ".shiliu-ai", "skill-refresh.json");
+}
+
+function lockFile(home) {
+  return path.join(home, ".shiliu-ai", "skill-refresh.lock");
+}
+
+async function acquireLock(home, retried = false) {
+  await mkdir(path.dirname(lockFile(home)), { recursive: true });
+  let handle;
+  try {
+    handle = await open(lockFile(home), "wx", 0o600);
+    await handle.writeFile(`${process.pid}\n`, "utf8");
+  } catch (error) {
+    await handle?.close();
+    if (error.code === "EEXIST") {
+      if (!retried) {
+        try {
+          const lockStat = await stat(lockFile(home));
+          if (Date.now() - lockStat.mtimeMs >= STALE_LOCK_MS) {
+            await unlink(lockFile(home));
+            return acquireLock(home, true);
+          }
+        } catch (lockError) {
+          if (lockError.code === "ENOENT") return acquireLock(home, true);
+          throw lockError;
+        }
+      }
+      return null;
+    }
+    throw error;
+  }
+  await handle.close();
+  return async () => {
+    try {
+      await unlink(lockFile(home));
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+  };
+}
+
+async function readState(home) {
+  try {
+    const value = JSON.parse(await readFile(stateFile(home), "utf8"));
+    if (value?.version === 1 && value.scopes && typeof value.scopes === "object") {
+      return value;
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT" && error.name !== "SyntaxError") throw error;
+  }
+  return { version: 1, scopes: {} };
+}
+
+async function writeState(home, state) {
+  const file = stateFile(home);
+  await mkdir(path.dirname(file), { recursive: true });
+  await writeFile(file, `${JSON.stringify(state, null, 2)}\n`, {
+    encoding: "utf8",
+    mode: 0o600,
+  });
+}
+
+function defaultRunUpdate({ cwd, platform = process.platform }) {
+  const command = platform === "win32" ? "npx.cmd" : "npx";
+  const result = spawnSync(
+    command,
+    ["-y", "skills", "update", SHILIU_SKILL_NAME, "-y"],
+    {
+      cwd,
+      encoding: "utf8",
+      windowsHide: true,
+      shell: false,
+      maxBuffer: 1024 * 1024,
+    },
+  );
+  if (result.error) throw result.error;
+  if (result.status !== 0) {
+    throw new Error(
+      result.stderr?.trim() ||
+        result.stdout?.trim() ||
+        `skills update 返回退出码 ${result.status}`,
+    );
+  }
+}
+
+function validTimestamp(value) {
+  const timestamp = Date.parse(value || "");
+  return Number.isFinite(timestamp) ? timestamp : null;
+}
+
+export async function refreshShiliuSkill({
+  home,
+  cwd = process.cwd(),
+  now = Date.now(),
+  force = false,
+  intervalMs = SKILL_REFRESH_INTERVAL_MS,
+  runUpdate = defaultRunUpdate,
+} = {}) {
+  if (!home) throw new Error("缺少用户目录，无法记录 Skill 检查时间");
+  const scope = path.resolve(cwd);
+  const state = await readState(home);
+  const previous = state.scopes[scope] || {};
+  const lastAttemptAt = validTimestamp(previous.lastAttemptAt);
+  if (!force && lastAttemptAt !== null && now - lastAttemptAt < intervalMs) {
+    return {
+      status: "skipped",
+      reason: "within_interval",
+      nextCheckAt: new Date(lastAttemptAt + intervalMs).toISOString(),
+    };
+  }
+
+  const releaseLock = await acquireLock(home);
+  if (!releaseLock) {
+    return {
+      status: "skipped",
+      reason: "refresh_in_progress",
+    };
+  }
+
+  try {
+    const latestState = await readState(home);
+    const latestPrevious = latestState.scopes[scope] || {};
+    const latestAttemptAt = validTimestamp(latestPrevious.lastAttemptAt);
+    if (
+      !force &&
+      latestAttemptAt !== null &&
+      now - latestAttemptAt < intervalMs
+    ) {
+      return {
+        status: "skipped",
+        reason: "within_interval",
+        nextCheckAt: new Date(latestAttemptAt + intervalMs).toISOString(),
+      };
+    }
+
+    const attemptedAt = new Date(now).toISOString();
+    latestState.scopes[scope] = {
+      ...latestPrevious,
+      lastAttemptAt: attemptedAt,
+    };
+    await writeState(home, latestState);
+
+    try {
+      await runUpdate({ cwd: scope });
+      latestState.scopes[scope].lastSuccessAt = attemptedAt;
+      await writeState(home, latestState);
+      return {
+        status: "checked",
+        checkedAt: attemptedAt,
+        nextCheckAt: new Date(now + intervalMs).toISOString(),
+      };
+    } catch (error) {
+      return {
+        status: "failed",
+        checkedAt: attemptedAt,
+        nextCheckAt: new Date(now + intervalMs).toISOString(),
+        message: error.message,
+      };
+    }
+  } finally {
+    await releaseLock();
+  }
+}
+
+export async function printSkillRefresh(options = {}) {
+  const result = await refreshShiliuSkill(options);
+  if (options.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return result;
+  }
+  if (result.status === "skipped") {
+    console.log(
+      result.reason === "refresh_in_progress"
+        ? "另一个石榴 Skill 检查正在进行，本次继续使用已安装 Skill。"
+        : `石榴 Skill 在24小时内已检查，下次检查时间：${result.nextCheckAt}`,
+    );
+  } else if (result.status === "checked") {
+    console.log(`石榴 Skill 检查完成，下次检查时间：${result.nextCheckAt}`);
+  } else {
+    console.warn(
+      `石榴 Skill 检查失败：${result.message}。已进入24小时冷却，本次继续使用已安装 Skill。`,
+    );
+  }
+  return result;
+}

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;
 }