@bigbrain-work/mcp-connect 1.2.2 → 1.3.0

package/src/credentials.js

@@ -1,160 +1,151 @@
-import { spawn } from 'node:child_process'
-import { spawnSync } from 'node:child_process'
-import { readFileSync } from 'node:fs'
-import { chmod, mkdir, readFile, writeFile } from 'node:fs/promises'
-import path from 'node:path'
-
-import { API_KEY_ENV } from './constants.js'
-
-function validateApiKey(value) {
-  const apiKey = value?.trim()
-  if (!apiKey) {
-    throw new Error('API Key 不能为空')
-  }
-  if (/\s/.test(apiKey)) {
-    throw new Error('API Key 不能包含空白字符')
-  }
-  if (apiKey.length < 12) {
-    throw new Error('API Key 长度异常，请确认复制完整')
-  }
-  return apiKey
+import { spawn, spawnSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { chmod, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+
+import { API_KEY_ENV } from "./constants.js";
+
+export function validateApiKey(value) {
+  const apiKey = value?.trim();
+  if (!apiKey) throw new Error("API Key 不能为空");
+  if (/\s/u.test(apiKey)) throw new Error("API Key 不能包含空白字符");
+  if (apiKey.length < 12) throw new Error("API Key 长度异常，请确认复制完整");
+  return apiKey;
 }
 
-export async function readHiddenInput(promptText, input = process.stdin, output = process.stdout) {
-  if (!input.isTTY || typeof input.setRawMode !== 'function') {
-    throw new Error(`当前终端不支持隐藏输入，请先设置 ${API_KEY_ENV} 环境变量后重试`)
+export async function readHiddenInput(
+  promptText,
+  input = process.stdin,
+  output = process.stdout,
+) {
+  if (!input.isTTY || typeof input.setRawMode !== "function") {
+    throw new Error(
+      `当前终端不支持隐藏输入，请先设置 ${API_KEY_ENV} 环境变量后重试`,
+    );
   }
 
-  output.write(promptText)
-  input.setRawMode(true)
-  input.resume()
-  input.setEncoding('utf8')
+  output.write(promptText);
+  input.setRawMode(true);
+  input.resume();
+  input.setEncoding("utf8");
 
   return new Promise((resolve, reject) => {
-    let value = ''
-
+    let value = "";
     const cleanup = () => {
-      input.off('data', onData)
-      input.setRawMode(false)
-      input.pause()
-    }
-
+      input.off("data", onData);
+      input.setRawMode(false);
+      input.pause();
+    };
     const onData = (chunk) => {
       for (const character of chunk) {
-        if (character === '\u0003') {
-          cleanup()
-          output.write('\n')
-          reject(new Error('操作已取消'))
-          return
+        if (character === "\u0003") {
+          cleanup();
+          output.write("\n");
+          reject(new Error("操作已取消"));
+          return;
         }
-        if (character === '\r' || character === '\n') {
-          cleanup()
-          output.write('\n')
-          resolve(value)
-          return
+        if (character === "\r" || character === "\n") {
+          cleanup();
+          output.write("\n");
+          resolve(value);
+          return;
         }
-        if (character === '\u007f' || character === '\b') {
-          value = value.slice(0, -1)
-          continue
+        if (character === "\u007f" || character === "\b") {
+          value = value.slice(0, -1);
+          continue;
         }
-        value += character
+        value += character;
       }
-    }
-
-    input.on('data', onData)
-  })
+    };
+    input.on("data", onData);
+  });
 }
 
-export async function resolveApiKey({ env = process.env, prompt = readHiddenInput } = {}) {
-  if (env[API_KEY_ENV]) {
-    return validateApiKey(env[API_KEY_ENV])
-  }
-  return validateApiKey(await prompt('请输入石榴 AI API Key（输入内容不会显示）：'))
+export async function resolveApiKey({
+  env = process.env,
+  prompt = readHiddenInput,
+} = {}) {
+  if (env[API_KEY_ENV]) return validateApiKey(env[API_KEY_ENV]);
+  return validateApiKey(
+    await prompt("请输入石榴 AI API Key（输入内容不会显示）："),
+  );
 }
 
-function runPowerShellWithInput(script, input) {
+function runPowerShellWithInput(script, input = "") {
   return new Promise((resolve, reject) => {
-    const child = spawn('powershell.exe', [
-      '-NoLogo',
-      '-NoProfile',
-      '-NonInteractive',
-      '-Command',
-      script,
-    ], {
-      windowsHide: true,
-      stdio: ['pipe', 'pipe', 'pipe'],
-    })
-
-    let stderr = ''
-    child.stderr.setEncoding('utf8')
-    child.stderr.on('data', (chunk) => {
-      stderr += chunk
-    })
-    child.on('error', reject)
-    child.on('close', (code) => {
-      if (code === 0) {
-        resolve()
-      } else {
-        reject(new Error(stderr.trim() || `PowerShell 返回退出码 ${code}`))
-      }
-    })
-    child.stdin.end(input)
-  })
+    const child = spawn(
+      "powershell.exe",
+      ["-NoLogo", "-NoProfile", "-NonInteractive", "-Command", script],
+      {
+        windowsHide: true,
+        stdio: ["pipe", "pipe", "pipe"],
+      },
+    );
+    let stderr = "";
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(stderr.trim() || `PowerShell 返回退出码 ${code}`));
+    });
+    child.stdin.end(input);
+  });
 }
 
 function shellQuote(value) {
-  return `'${value.replaceAll("'", "'\\''")}'`
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+
+function posixPaths(home, env) {
+  const configDir = path.join(home, ".config", "shiliu-ai");
+  const envFile = path.join(configDir, "env");
+  const shellName = path.basename(env.SHELL || "");
+  const profileName =
+    shellName === "zsh"
+      ? ".zprofile"
+      : shellName === "bash"
+        ? ".bash_profile"
+        : ".profile";
+  return { configDir, envFile, profilePath: path.join(home, profileName) };
 }
 
 async function persistPosixApiKey(apiKey, home, env) {
-  const configDir = path.join(home, '.config', 'shiliu-ai')
-  const envFile = path.join(configDir, 'env')
-  await mkdir(configDir, { recursive: true })
+  const { configDir, envFile, profilePath } = posixPaths(home, env);
+  await mkdir(configDir, { recursive: true });
   await writeFile(envFile, `export ${API_KEY_ENV}=${shellQuote(apiKey)}\n`, {
-    encoding: 'utf8',
+    encoding: "utf8",
     mode: 0o600,
-  })
-  await chmod(envFile, 0o600)
+  });
+  await chmod(envFile, 0o600);
 
-  const shellName = path.basename(env.SHELL || '')
-  const profileName = shellName === 'zsh'
-    ? '.zprofile'
-    : shellName === 'bash'
-      ? '.bash_profile'
-      : '.profile'
-  const profilePath = path.join(home, profileName)
-  const sourceLine = `. ${shellQuote(envFile)} # shiliu-ai\n`
-  let profile = ''
+  const sourceLine = `. ${shellQuote(envFile)} # shiliu-ai\n`;
+  let profile = "";
   try {
-    profile = await readFile(profilePath, 'utf8')
+    profile = await readFile(profilePath, "utf8");
   } catch (error) {
-    if (error.code !== 'ENOENT') {
-      throw error
-    }
+    if (error.code !== "ENOENT") throw error;
   }
-  if (!profile.includes('# shiliu-ai')) {
-    const separator = profile && !profile.endsWith('\n') ? '\n' : ''
-    await writeFile(profilePath, `${profile}${separator}${sourceLine}`, 'utf8')
+  if (!profile.includes("# shiliu-ai")) {
+    const separator = profile && !profile.endsWith("\n") ? "\n" : "";
+    await writeFile(profilePath, `${profile}${separator}${sourceLine}`, "utf8");
   }
 }
 
-export async function persistApiKey(apiKey, {
-  dryRun = false,
-  home,
-  platform = process.platform,
-  env = process.env,
-} = {}) {
-  if (dryRun) {
-    return
-  }
-
-  if (platform === 'win32') {
-    const script = `$value = [Console]::In.ReadToEnd(); [Environment]::SetEnvironmentVariable('${API_KEY_ENV}', $value, 'User')`
-    await runPowerShellWithInput(script, apiKey)
+export async function persistApiKey(
+  apiKey,
+  { dryRun = false, home, platform = process.platform, env = process.env } = {},
+) {
+  if (dryRun) return;
+  if (platform === "win32") {
+    const script = `$value = [Console]::In.ReadToEnd(); [Environment]::SetEnvironmentVariable('${API_KEY_ENV}', $value, 'User')`;
+    await runPowerShellWithInput(script, apiKey);
   } else {
-    await persistPosixApiKey(apiKey, home, env)
+    await persistPosixApiKey(apiKey, home, env);
   }
-  process.env[API_KEY_ENV] = apiKey
+  process.env[API_KEY_ENV] = apiKey;
 }
 
 export function readPersistedApiKey({
@@ -162,37 +153,64 @@ export function readPersistedApiKey({
   env = process.env,
   home,
 } = {}) {
-  if (env[API_KEY_ENV]) {
-    return env[API_KEY_ENV]
-  }
-
-  if (platform === 'win32') {
-    const result = spawnSync('powershell.exe', [
-      '-NoLogo',
-      '-NoProfile',
-      '-NonInteractive',
-      '-Command',
-      `[Console]::Out.Write([Environment]::GetEnvironmentVariable('${API_KEY_ENV}', 'User'))`,
-    ], {
-      windowsHide: true,
-      encoding: 'utf8',
-    })
-    return result.status === 0 ? result.stdout.trim() : ''
+  if (env[API_KEY_ENV]) return env[API_KEY_ENV];
+  if (platform === "win32") {
+    const result = spawnSync(
+      "powershell.exe",
+      [
+        "-NoLogo",
+        "-NoProfile",
+        "-NonInteractive",
+        "-Command",
+        `[Console]::Out.Write([Environment]::GetEnvironmentVariable('${API_KEY_ENV}', 'User'))`,
+      ],
+      { windowsHide: true, encoding: "utf8" },
+    );
+    return result.status === 0 ? result.stdout.trim() : "";
   }
 
   try {
-    const content = readFileSync(path.join(home, '.config', 'shiliu-ai', 'env'), 'utf8')
-    const prefix = `export ${API_KEY_ENV}=`
-    const line = content.split(/\r?\n/u).find((item) => item.startsWith(prefix))
-    if (!line) {
-      return ''
-    }
-    const encodedValue = line.slice(prefix.length)
+    const { envFile } = posixPaths(home, env);
+    const content = readFileSync(envFile, "utf8");
+    const prefix = `export ${API_KEY_ENV}=`;
+    const line = content
+      .split(/\r?\n/u)
+      .find((item) => item.startsWith(prefix));
+    if (!line) return "";
+    const encodedValue = line.slice(prefix.length);
     if (encodedValue.startsWith("'") && encodedValue.endsWith("'")) {
-      return encodedValue.slice(1, -1).replaceAll("'\\''", "'")
+      return encodedValue.slice(1, -1).replaceAll("'\\''", "'");
     }
-    return encodedValue
+    return encodedValue;
   } catch {
-    return ''
+    return "";
+  }
+}
+
+export async function clearPersistedApiKey({
+  home,
+  platform = process.platform,
+  env = process.env,
+  dryRun = false,
+} = {}) {
+  if (dryRun) return;
+  if (platform === "win32") {
+    await runPowerShellWithInput(
+      `[Environment]::SetEnvironmentVariable('${API_KEY_ENV}', $null, 'User')`,
+    );
+  } else {
+    const { envFile, profilePath } = posixPaths(home, env);
+    await rm(envFile, { force: true });
+    try {
+      const profile = await readFile(profilePath, "utf8");
+      const next = profile
+        .split(/(?<=\n)/u)
+        .filter((line) => !line.includes("# shiliu-ai"))
+        .join("");
+      if (next !== profile) await writeFile(profilePath, next, "utf8");
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
   }
+  delete process.env[API_KEY_ENV];
 }

package/src/detection.js

@@ -1,24 +1,23 @@
-import { access } from 'node:fs/promises'
-import path from 'node:path'
-import { spawnSync } from 'node:child_process'
-
+import { spawnSync } from "node:child_process";
+import { access } from "node:fs/promises";
+import path from "node:path";
 
 export function commandExists(command, spawn = spawnSync) {
-  const result = spawn(command, ['--version'], {
-    encoding: 'utf8',
+  const result = spawn(command, ["--version"], {
+    encoding: "utf8",
     windowsHide: true,
     shell: false,
     timeout: 5000,
-  })
-  return !result.error && result.status === 0
+  });
+  return !result.error && result.status === 0;
 }
 
 async function pathExists(targetPath) {
   try {
-    await access(targetPath)
-    return true
+    await access(targetPath);
+    return true;
   } catch {
-    return false
+    return false;
   }
 }
 
@@ -27,15 +26,11 @@ export async function detectInstalledAgents({
   hasCommand = commandExists,
   exists = pathExists,
 } = {}) {
-  const agents = []
-  if (hasCommand('codex')) {
-    agents.push('codex')
-  }
-  if (hasCommand('claude')) {
-    agents.push('claude')
-  }
-  if (hasCommand('cursor') || await exists(path.join(home, '.cursor'))) {
-    agents.push('cursor')
+  const agents = [];
+  if (hasCommand("codex")) agents.push("codex");
+  if (hasCommand("claude")) agents.push("claude");
+  if (hasCommand("cursor") || (await exists(path.join(home, ".cursor")))) {
+    agents.push("cursor");
   }
-  return agents
+  return agents;
 }

package/src/device-auth-client.js

@@ -0,0 +1,130 @@
+import QRCode from "qrcode";
+
+import { AUTH_URL } from "./constants.js";
+
+export class DeviceAuthError extends Error {
+  constructor(code, message, status) {
+    super(message || code);
+    this.name = "DeviceAuthError";
+    this.code = code;
+    this.status = status;
+  }
+}
+
+async function requestJson(url, options, fetchImpl) {
+  const response = await fetchImpl(url, {
+    ...options,
+    headers: {
+      Accept: "application/json",
+      "Content-Type": "application/json",
+      ...(options.headers || {}),
+    },
+    signal: options.signal || AbortSignal.timeout(15000),
+  });
+  const payload = await response.json().catch(() => ({}));
+  if (!response.ok) {
+    const body = payload.response || payload;
+    throw new DeviceAuthError(
+      body.error || "request_failed",
+      body.error_description || body.message || `HTTP ${response.status}`,
+      response.status,
+    );
+  }
+  return payload;
+}
+
+export class DeviceAuthClient {
+  constructor({ baseUrl = AUTH_URL, fetchImpl = fetch } = {}) {
+    this.baseUrl = baseUrl.replace(/\/$/u, "");
+    this.fetchImpl = fetchImpl;
+  }
+
+  start() {
+    return requestJson(
+      `${this.baseUrl}/code`,
+      { method: "POST" },
+      this.fetchImpl,
+    );
+  }
+
+  exchange(deviceCode) {
+    return requestJson(
+      `${this.baseUrl}/token`,
+      { method: "POST", body: JSON.stringify({ device_code: deviceCode }) },
+      this.fetchImpl,
+    );
+  }
+
+  refresh(refreshToken) {
+    return requestJson(
+      `${this.baseUrl}/refresh`,
+      { method: "POST", body: JSON.stringify({ refresh_token: refreshToken }) },
+      this.fetchImpl,
+    );
+  }
+
+  revoke(refreshToken) {
+    return requestJson(
+      `${this.baseUrl}/revoke`,
+      { method: "POST", body: JSON.stringify({ refresh_token: refreshToken }) },
+      this.fetchImpl,
+    );
+  }
+}
+
+export function normalizeTokenResponse(response, now = Date.now()) {
+  if (
+    typeof response?.access_token !== "string" ||
+    typeof response?.refresh_token !== "string" ||
+    !Number.isFinite(Number(response?.expires_in))
+  ) {
+    throw new Error("授权服务返回的令牌格式无效");
+  }
+  return {
+    accessToken: response.access_token,
+    refreshToken: response.refresh_token,
+    expiresAt: now + Number(response.expires_in) * 1000,
+    tokenType: response.token_type || "Bearer",
+    scope: response.scope || "mcp",
+  };
+}
+
+export async function renderQrCode(value) {
+  return QRCode.toString(value, {
+    type: "terminal",
+    small: true,
+    errorCorrectionLevel: "M",
+  });
+}
+
+function defaultSleep(milliseconds) {
+  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+
+export async function waitForDeviceAuthorization(
+  start,
+  client,
+  { sleep = defaultSleep, now = Date.now, onPending = () => {} } = {},
+) {
+  const deadline = now() + Number(start.expires_in) * 1000;
+  let intervalSeconds = Number(start.interval) || 5;
+
+  while (now() < deadline) {
+    await sleep(intervalSeconds * 1000);
+    try {
+      return await client.exchange(start.device_code);
+    } catch (error) {
+      if (!(error instanceof DeviceAuthError)) throw error;
+      if (error.code === "authorization_pending") {
+        onPending();
+        continue;
+      }
+      if (error.code === "slow_down") {
+        intervalSeconds += 5;
+        continue;
+      }
+      throw error;
+    }
+  }
+  throw new DeviceAuthError("expired_token", "登录二维码已过期，请重试");
+}

package/src/login-flow.js

@@ -0,0 +1,39 @@
+import { normalizeTokenResponse } from "./device-auth-client.js";
+import { probeMcp } from "./status.js";
+
+export async function verifyAndPersistLogin({
+  response,
+  client,
+  tokenStore,
+  url,
+  probe = probeMcp,
+}) {
+  const tokenSet = normalizeTokenResponse(response);
+  const remote = await probe(tokenSet.accessToken, { url });
+  if (!remote.ok) {
+    const validationError = new Error(`登录令牌验证失败：${remote.detail}`);
+    try {
+      await client.revoke(tokenSet.refreshToken);
+    } catch (revokeError) {
+      throw new AggregateError(
+        [validationError, revokeError],
+        `登录令牌验证失败，且远端令牌撤销失败：${remote.detail}`,
+      );
+    }
+    throw validationError;
+  }
+  try {
+    await tokenStore.save(tokenSet);
+  } catch (error) {
+    try {
+      await client.revoke(tokenSet.refreshToken);
+    } catch (revokeError) {
+      throw new AggregateError(
+        [error, revokeError],
+        `本机凭据保存失败，且远端令牌撤销失败：${error.message}`,
+      );
+    }
+    throw error;
+  }
+  return remote;
+}