@yuzc-001/grasp 0.6.6

package/src/layer1-bridge/chrome.js

@@ -0,0 +1,416 @@
+import { chromium } from 'playwright-core';
+import { spawn } from 'child_process';
+import { join } from 'path';
+import { homedir } from 'os';
+import { detectChromePath, startChromeHint } from '../cli/detect-chrome.js';
+import { writeRuntimeStatus } from '../server/runtime-status.js';
+import { getActiveTaskFrame, isSafeModeEnabled } from '../server/state.js';
+
+const CDP_URL = process.env.CHROME_CDP_URL || 'http://localhost:9222';
+const DEFAULT_RETRY_DELAYS = [0, 250, 1000];
+const SAFE_MODE = isSafeModeEnabled();
+
+async function autoLaunchChrome(cdpUrl) {
+  const chromePath = detectChromePath();
+  if (!chromePath) return false;
+
+  const parsedUrl = new URL(cdpUrl);
+  const localHosts = new Set(['localhost', '127.0.0.1', '::1']);
+  if (!localHosts.has(parsedUrl.hostname)) return false;
+
+  const port = parsedUrl.port || '9222';
+  const userDataDir = join(homedir(), 'chrome-grasp');
+
+  console.error(`[Grasp] Chrome not running — auto-launching: ${chromePath}`);
+  spawn(chromePath, [
+    `--remote-debugging-port=${port}`,
+    `--user-data-dir=${userDataDir}`,
+    '--no-first-run',
+    '--no-default-browser-check',
+    '--start-maximized',
+  ], { detached: true, stdio: 'ignore' }).unref();
+
+  for (let attempt = 0; attempt < 20; attempt += 1) {
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    try {
+      const response = await fetch(`${cdpUrl}/json/version`, { signal: AbortSignal.timeout(1500) });
+      if (response.ok) {
+        console.error('[Grasp] Auto-launched Chrome is ready.');
+        return true;
+      }
+    } catch {
+      // not ready yet
+    }
+  }
+
+  console.error('[Grasp] Auto-launch: Chrome did not become reachable in time.');
+  return false;
+}
+
+async function defaultConnect() {
+  try {
+    const browser = await chromium.connectOverCDP(CDP_URL);
+    console.error('[Grasp] Connected to Chrome via CDP:', CDP_URL);
+    return browser;
+  } catch (err) {
+    throw new Error(
+      `Chrome not reachable at ${CDP_URL}.\n` +
+      `Start Chrome with remote debugging enabled:\n` +
+      `  ${startChromeHint(CDP_URL)}\n` +
+      `Or run: grasp status  to diagnose the problem.\n` +
+      `(${err.message})`
+    );
+  }
+}
+
+const defaultPersistStatus = async (snapshot) => {
+  await writeRuntimeStatus(snapshot);
+};
+
+function runPersist(persistFn, snapshot) {
+  if (!persistFn) return;
+  try {
+    const result = persistFn(snapshot);
+    if (result && typeof result.catch === 'function') {
+      result.catch(() => {});
+    }
+  } catch {
+    // swallow
+  }
+}
+
+function clearTargetSession(state) {
+  if (state) {
+    const activeTaskFrame = getActiveTaskFrame(state);
+    if (activeTaskFrame) {
+      activeTaskFrame.pinnedTarget = null;
+      state.targetSession = null;
+      return;
+    }
+    if (state.targetSession) {
+      state.targetSession = null;
+    }
+  }
+}
+
+function getPinnedTargetSession(state) {
+  const activeTaskFrame = getActiveTaskFrame(state);
+  if (activeTaskFrame) {
+    return activeTaskFrame.pinnedTarget ?? null;
+  }
+  return state?.targetSession ?? null;
+}
+
+function isPinnedTargetAvailable(page, browser) {
+  if (!page) return false;
+  if (page.isClosed?.() === true) return false;
+
+  const contexts = browser?.contexts?.() ?? [];
+  for (const context of contexts) {
+    const pages = context?.pages?.() ?? [];
+    if (pages.includes(page)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function matchesPinnedTarget(page, targetSession) {
+  const currentUrl = page?.url?.() ?? '';
+  if (!currentUrl || !targetSession?.url) return false;
+  if (currentUrl !== targetSession.url) return false;
+  if (currentUrl.startsWith('chrome://')) return false;
+  if (currentUrl.startsWith('chrome-extension://')) return false;
+  if (currentUrl.startsWith('about:')) return false;
+  return true;
+}
+
+export async function pinTargetPage(page, state) {
+  const targetSession = {
+    page,
+    url: page.url(),
+    title: await page.title(),
+  };
+  if (state) {
+    const activeTaskFrame = getActiveTaskFrame(state);
+    if (activeTaskFrame) {
+      activeTaskFrame.pinnedTarget = targetSession;
+      state.targetSession = null;
+    } else {
+      state.targetSession = targetSession;
+    }
+  }
+  return targetSession;
+}
+
+export function createConnectionSupervisor({
+  connect = defaultConnect,
+  now = () => Date.now(),
+  retryDelays = DEFAULT_RETRY_DELAYS,
+  persistStatus = defaultPersistStatus,
+  safeMode = SAFE_MODE,
+  cdpUrl = CDP_URL,
+  autoLaunch = autoLaunchChrome,
+} = {}) {
+  let browser = null;
+  let pending = null;
+  let status = {
+    state: 'idle',
+    retryCount: 0,
+    lastError: null,
+    lastAttemptAt: null,
+    connectedAt: null,
+    cdpUrl,
+    safeMode,
+    updatedAt: now(),
+  };
+
+  function updateStatus(updates) {
+    status = {
+      ...status,
+      ...updates,
+      cdpUrl,
+      safeMode,
+      updatedAt: now(),
+    };
+    runPersist(persistStatus, status);
+    return status;
+  }
+
+  function attachDisconnectListener(instance) {
+    if (!instance || typeof instance.once !== 'function') return;
+    instance.once('disconnected', () => {
+      browser = null;
+      updateStatus({ state: 'disconnected', lastError: 'browser disconnected' });
+    });
+  }
+
+  async function attemptConnect() {
+    updateStatus({ state: 'connecting', lastError: null });
+
+    for (let index = 0; index < retryDelays.length; index += 1) {
+      const delayMs = retryDelays[index];
+      if (delayMs) {
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+      }
+
+      const attemptCount = index + 1;
+      updateStatus({
+        retryCount: attemptCount,
+        lastAttemptAt: now(),
+        lastError: null,
+      });
+
+      try {
+        const candidate = await connect();
+        browser = candidate;
+        attachDisconnectListener(candidate);
+        updateStatus({
+          state: 'connected',
+          connectedAt: now(),
+          lastError: null,
+          retryCount: attemptCount,
+        });
+        return candidate;
+      } catch (error) {
+        updateStatus({ lastError: error.message });
+      }
+    }
+
+    if (autoLaunch) {
+      updateStatus({ state: 'auto_launching', lastError: 'CDP unreachable, attempting auto-launch' });
+      const launched = await autoLaunch(cdpUrl);
+      if (launched) {
+        try {
+          const candidate = await connect();
+          browser = candidate;
+          attachDisconnectListener(candidate);
+          updateStatus({
+            state: 'connected',
+            connectedAt: now(),
+            lastError: null,
+            retryCount: retryDelays.length + 1,
+          });
+          return candidate;
+        } catch (error) {
+          updateStatus({ lastError: error.message });
+        }
+      }
+    }
+
+    updateStatus({ state: 'CDP_UNREACHABLE', retryCount: retryDelays.length, lastAttemptAt: now() });
+    throw new Error(status.lastError ?? 'CDP unreachable');
+  }
+
+  async function getBrowser() {
+    if (browser?.isConnected?.()) {
+      updateStatus({ state: 'connected', connectedAt: now(), lastError: null });
+      return browser;
+    }
+
+    if (pending) {
+      return pending;
+    }
+
+    pending = attemptConnect();
+    try {
+      return await pending;
+    } finally {
+      pending = null;
+    }
+  }
+
+  function getStatus() {
+    return status;
+  }
+
+  function reset() {
+    browser = null;
+    pending = null;
+    updateStatus({
+      cdp: { state: 'unknown', browserVersion: null, protocolVersion: null },
+      page: { state: 'unknown', title: null, url: null },
+      browser_process: { state: 'unknown', pid: null },
+      server: {
+        state: 'idle',
+        retryCount: 0,
+        lastError: null,
+        lastAttemptAt: null,
+        connectedAt: null,
+      },
+    });
+  }
+
+  return { getBrowser, getStatus, reset };
+}
+
+const supervisor = createConnectionSupervisor();
+
+async function getBrowser() {
+  return supervisor.getBrowser();
+}
+
+async function getActivePage({ state = null, browser = null } = {}) {
+  const resolvedBrowser = browser ?? await getBrowser();
+  const pinnedTarget = getPinnedTargetSession(state);
+
+  if (pinnedTarget?.page) {
+    const pinnedPage = pinnedTarget.page;
+    if (isPinnedTargetAvailable(pinnedPage, resolvedBrowser) && matchesPinnedTarget(pinnedPage, pinnedTarget)) {
+      return pinnedPage;
+    }
+    clearTargetSession(state);
+  }
+
+  const context = resolvedBrowser.contexts()[0];
+  if (!context) throw new Error('No browser context available.');
+  const pages = context.pages();
+
+  const userPages = pages.filter((page) => {
+    const url = page.url();
+    if (!url) return false;
+    if (url.startsWith('chrome://')) return false;
+    if (url.startsWith('chrome-extension://')) return false;
+    if (url.startsWith('about:')) return false;
+    return true;
+  });
+
+  if (userPages.length === 0) {
+    if (pages.length > 0) return pages[pages.length - 1];
+    const newPage = await context.newPage();
+    console.error('[Grasp] No open tabs — created a blank tab.');
+    return newPage;
+  }
+
+  for (const page of userPages) {
+    try {
+      const isVisible = await page.evaluate(() => document.visibilityState === 'visible');
+      if (isVisible) return page;
+    } catch {
+      // Page still loading — skip
+    }
+  }
+
+  return userPages[userPages.length - 1];
+}
+
+async function navigateTo(url, { state = null, browser = null } = {}) {
+  const page = await getActivePage({ state, browser });
+
+  try {
+    await page.goto(url, { waitUntil: 'domcontentloaded', timeout: 30000 });
+  } catch (err) {
+    if (err.name === 'TimeoutError' || err.message?.includes('timeout')) {
+      console.error(
+        `[Grasp] Navigation to ${url} timed out, continuing with partially loaded page.`
+      );
+    } else {
+      throw err;
+    }
+  }
+
+  return page;
+}
+
+async function getTabs() {
+  const browser = await getBrowser();
+  const context = browser.contexts()[0];
+  if (!context) throw new Error('No browser context available.');
+  const pages = context.pages();
+  return Promise.all(
+    pages.map(async (p, i) => ({
+      index: i,
+      title: await p.title().catch(() => ''),
+      url: p.url(),
+      isUser: p.url() && !p.url().startsWith('chrome://') && !p.url().startsWith('about:'),
+    }))
+  );
+}
+
+async function switchTab(index) {
+  const browser = await getBrowser();
+  const context = browser.contexts()[0];
+  if (!context) throw new Error('No browser context available.');
+  const pages = context.pages();
+  if (index < 0 || index >= pages.length) {
+    throw new Error(`Tab index ${index} out of range (0-${pages.length - 1})`);
+  }
+  await pages[index].bringToFront();
+  return pages[index];
+}
+
+async function newTab(url) {
+  const browser = await getBrowser();
+  const context = browser.contexts()[0];
+  if (!context) throw new Error('No browser context available.');
+  const page = await context.newPage();
+  try {
+    await page.goto(url, { waitUntil: 'domcontentloaded', timeout: 30000 });
+  } catch (err) {
+    if (!err.message?.includes('timeout')) {
+      await page.close().catch(() => {});
+      throw err;
+    }
+    console.error(`[Grasp] newTab navigation timeout for ${url}, continuing.`);
+  }
+  await page.bringToFront();
+  return page;
+}
+
+async function trustedContextOpen(url) {
+  return newTab(url);
+}
+
+async function closeTab(index) {
+  const browser = await getBrowser();
+  const context = browser.contexts()[0];
+  if (!context) throw new Error('No browser context available.');
+  const pages = context.pages();
+  if (index < 0 || index >= pages.length) {
+    throw new Error(`Tab index ${index} out of range (0-${pages.length - 1})`);
+  }
+  await pages[index].close();
+}
+
+export { getBrowser, getActivePage, navigateTo, getTabs, switchTab, newTab, trustedContextOpen, closeTab };

package/src/layer1-bridge/webmcp.js

@@ -0,0 +1,143 @@
+/**
+ * Layer 1 WebMCP 适配层
+ * 每次 navigate 后自动探测页面是否支持 WebMCP：
+ *   - 命中 → 走原生工具通道（零 DOM 解析）
+ *   - 未命中 → 静默降级到 CDP 模式
+ */
+
+/**
+ * 探测页面是否支持 WebMCP。
+ * 两步探测，总开销 < 50ms。
+ *
+ * @param {import('playwright').Page} page
+ * @returns {Promise<WebMCPInfo>}
+ *
+ * @typedef {{ available: true, source: 'window' | 'well-known', endpoint: string, tools: any[] } | { available: false }} WebMCPInfo
+ */
+export async function probe(page) {
+  // Step 1（~1ms）：检测 window 对象上的 WebMCP 标记
+  try {
+    const windowResult = await page.evaluate(() => {
+      // 检测 window.__webmcp__
+      if (typeof window.__webmcp__ !== 'undefined') {
+        return {
+          found: true,
+          source: 'window',
+          endpoint: window.__webmcp__?.endpoint ?? window.location.origin,
+        };
+      }
+      // 检测 window.MCP
+      if (typeof window.MCP !== 'undefined') {
+        return {
+          found: true,
+          source: 'window',
+          endpoint: window.MCP?.endpoint ?? window.location.origin,
+        };
+      }
+      // 检测 <meta name="mcp-endpoint">
+      const meta = document.querySelector('meta[name="mcp-endpoint"]');
+      if (meta) {
+        return {
+          found: true,
+          source: 'window',
+          endpoint: meta.getAttribute('content') ?? window.location.origin,
+        };
+      }
+      return { found: false };
+    });
+
+    if (windowResult.found) {
+      return {
+        available: true,
+        source: 'window',
+        endpoint: windowResult.endpoint,
+        tools: [],
+      };
+    }
+  } catch {
+    // 静默捕获，继续 Step 2
+  }
+
+  // Step 2（~50ms 上限）：尝试 well-known 端点
+  try {
+    const wellKnownResult = await page.evaluate(async () => {
+      const url = `${window.location.origin}/.well-known/mcp`;
+      const response = await fetch(url, {
+        signal: AbortSignal.timeout(3000),
+      });
+      if (!response.ok) return { found: false };
+      const data = await response.json();
+      return { found: true, url, tools: data.tools ?? [] };
+    });
+
+    if (wellKnownResult.found) {
+      return {
+        available: true,
+        source: 'well-known',
+        endpoint: wellKnownResult.url,
+        tools: wellKnownResult.tools,
+      };
+    }
+  } catch {
+    // 静默捕获
+  }
+
+  return { available: false };
+}
+
+/**
+ * 列出当前页面可用的 WebMCP 工具。
+ *
+ * @param {import('playwright').Page} page
+ * @param {WebMCPInfo} info
+ * @returns {Promise<any[]>}
+ */
+export async function listTools(page, info) {
+  if (!info.available) return [];
+
+  try {
+    if (info.source === 'window') {
+      return await page.evaluate(() => {
+        return window.__webmcp__?.tools ?? window.MCP?.tools ?? [];
+      });
+    }
+
+    if (info.source === 'well-known') {
+      return info.tools ?? [];
+    }
+  } catch {
+    // 静默捕获
+  }
+
+  return [];
+}
+
+/**
+ * 调用指定的 WebMCP 工具。
+ *
+ * @param {import('playwright').Page} page
+ * @param {WebMCPInfo} info
+ * @param {string} toolName
+ * @param {Record<string, unknown>} args
+ * @returns {Promise<any>}
+ */
+export async function callTool(page, info, toolName, args = {}) {
+  if (!info.available) {
+    throw new Error('WebMCP not available on this page');
+  }
+
+  if (info.source === 'well-known') {
+    throw new Error('WebMCP call is not supported for well-known source. The page does not expose a window call function.');
+  }
+
+  const result = await page.evaluate(
+    async ({ toolName, args }) => {
+      const callFn = window.__webmcp__?.call ?? window.MCP?.call;
+      if (!callFn) return { __error: 'WebMCP call function not found' };
+      return callFn(toolName, args);
+    },
+    { toolName, args },
+  );
+  if (result?.__error) throw new Error(result.__error);
+  return result;
+}