m365connector 0.3.5 → 0.3.7

package/src/browser-session.js

@@ -0,0 +1,619 @@
+import { EventEmitter } from "node:events";
+import fs from "node:fs";
+import http from "node:http";
+import os from "node:os";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { WebSocket } from "ws";
+
+const DEFAULT_EDGE_PORT = 52367;
+const DEFAULT_NAVIGATION_TIMEOUT_MS = 30000;
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function expandHome(value) {
+  const text = String(value || "");
+  if (text === "~") {
+    return os.homedir();
+  }
+  if (text.startsWith("~/")) {
+    return path.join(os.homedir(), text.slice(2));
+  }
+  return text;
+}
+
+function requestJson(url, options = {}) {
+  const method = options.method || "GET";
+  const timeoutMs = Number(options.timeoutMs || 2000);
+  return new Promise((resolve, reject) => {
+    const req = http.request(url, { method, timeout: timeoutMs }, (res) => {
+      let data = "";
+      res.on("data", (chunk) => { data += chunk; });
+      res.on("end", () => {
+        if (res.statusCode < 200 || res.statusCode >= 300) {
+          reject(new Error(`HTTP ${res.statusCode}: ${data.slice(0, 200)}`));
+          return;
+        }
+        try {
+          resolve(data ? JSON.parse(data) : null);
+        } catch (err) {
+          reject(err);
+        }
+      });
+    });
+    req.on("timeout", () => req.destroy(new Error("timeout")));
+    req.on("error", reject);
+    req.end();
+  });
+}
+
+function requestText(url, options = {}) {
+  const method = options.method || "GET";
+  const timeoutMs = Number(options.timeoutMs || 2000);
+  return new Promise((resolve, reject) => {
+    const req = http.request(url, { method, timeout: timeoutMs }, (res) => {
+      let data = "";
+      res.on("data", (chunk) => { data += chunk; });
+      res.on("end", () => {
+        if (res.statusCode < 200 || res.statusCode >= 300) {
+          reject(new Error(`HTTP ${res.statusCode}: ${data.slice(0, 200)}`));
+          return;
+        }
+        resolve(data);
+      });
+    });
+    req.on("timeout", () => req.destroy(new Error("timeout")));
+    req.on("error", reject);
+    req.end();
+  });
+}
+
+function findEdgeExecutable() {
+  if (process.env.M365C_EDGE_PATH) {
+    return expandHome(process.env.M365C_EDGE_PATH);
+  }
+
+  const candidates = [
+    "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
+    path.join(os.homedir(), "Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge"),
+    "/usr/bin/microsoft-edge",
+    "/usr/bin/microsoft-edge-stable",
+    "/opt/microsoft/msedge/microsoft-edge"
+  ];
+
+  return candidates.find((candidate) => fs.existsSync(candidate)) || "msedge";
+}
+
+function defaultUserDataDir() {
+  if (process.env.M365C_EDGE_USER_DATA_DIR) {
+    return expandHome(process.env.M365C_EDGE_USER_DATA_DIR);
+  }
+
+  const phantomwrightProfile = path.join(
+    os.homedir(),
+    "Library/Caches/phantomwright-cli/daemon/ud-m365"
+  );
+  if (fs.existsSync(phantomwrightProfile)) {
+    return phantomwrightProfile;
+  }
+
+  return path.join(os.homedir(), ".m365connector", "edge-profile");
+}
+
+function normalizeHeaderMap(headers = {}) {
+  const out = {};
+  for (const [key, value] of Object.entries(headers || {})) {
+    out[String(key).toLowerCase()] = String(value);
+  }
+  return out;
+}
+
+export class CdpPage extends EventEmitter {
+  constructor(session, target) {
+    super();
+    this.session = session;
+    this.id = target.id;
+    this.target = target;
+    this.url = target.url || "";
+    this.wsUrl = target.webSocketDebuggerUrl;
+    this.ws = null;
+    this.nextId = 1;
+    this.pending = new Map();
+    this.contexts = new Map();
+    this.requestUrls = new Map();
+    this.mainFrameId = null;
+    this.loaded = false;
+    this.closed = false;
+  }
+
+  async connect() {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      return;
+    }
+
+    this.ws = new WebSocket(this.wsUrl);
+    this.ws.on("message", (raw) => this.#handleMessage(raw));
+    this.ws.on("close", () => {
+      this.closed = true;
+      for (const pending of this.pending.values()) {
+        clearTimeout(pending.timeout);
+        pending.reject(new Error("CDP page closed"));
+      }
+      this.pending.clear();
+    });
+
+    await new Promise((resolve, reject) => {
+      this.ws.once("open", resolve);
+      this.ws.once("error", reject);
+    });
+
+    await this.send("Page.enable");
+    await this.send("Runtime.enable");
+    await this.send("Network.enable", {
+      maxTotalBufferSize: 10000000,
+      maxResourceBufferSize: 2000000
+    });
+  }
+
+  #handleMessage(raw) {
+    let message;
+    try {
+      message = JSON.parse(String(raw));
+    } catch {
+      return;
+    }
+
+    if (message.id && this.pending.has(message.id)) {
+      const pending = this.pending.get(message.id);
+      this.pending.delete(message.id);
+      clearTimeout(pending.timeout);
+      if (message.error) {
+        pending.reject(new Error(message.error.message || JSON.stringify(message.error)));
+      } else {
+        pending.resolve(message.result);
+      }
+      return;
+    }
+
+    if (message.method === "Runtime.executionContextCreated") {
+      const context = message.params?.context;
+      const frameId = context?.auxData?.frameId;
+      if (context?.id && frameId) {
+        this.contexts.set(context.id, {
+          id: context.id,
+          frameId,
+          isDefault: Boolean(context.auxData?.isDefault),
+          origin: context.origin || "",
+          name: context.name || ""
+        });
+      }
+      return;
+    }
+
+    if (message.method === "Runtime.executionContextDestroyed") {
+      this.contexts.delete(message.params?.executionContextId);
+      return;
+    }
+
+    if (message.method === "Runtime.executionContextsCleared") {
+      this.contexts.clear();
+      return;
+    }
+
+    if (message.method === "Page.frameNavigated") {
+      if (!message.params?.frame?.parentId) {
+        this.mainFrameId = message.params.frame.id || this.mainFrameId;
+        this.url = message.params.frame.url || this.url;
+        this.loaded = false;
+      }
+      return;
+    }
+
+    if (message.method === "Page.loadEventFired") {
+      this.loaded = true;
+      this.emit("updated", { status: "complete" });
+      return;
+    }
+
+    if (message.method === "Network.requestWillBeSent") {
+      this.requestUrls.set(message.params?.requestId, message.params?.request?.url || "");
+      return;
+    }
+
+    if (message.method === "Network.requestWillBeSentExtraInfo") {
+      const requestId = message.params?.requestId;
+      const headers = normalizeHeaderMap(message.params?.headers || {});
+      const authorization = headers.authorization || "";
+      if (authorization.startsWith("Bearer ")) {
+        this.emit("bearer", {
+          token: authorization.slice("Bearer ".length).trim(),
+          url: this.requestUrls.get(requestId) || ""
+        });
+      }
+    }
+  }
+
+  send(method, params = {}, timeoutMs = 10000) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      return Promise.reject(new Error("CDP page is not connected"));
+    }
+
+    const id = this.nextId++;
+    const payload = { id, method, params };
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`CDP timeout: ${method}`));
+      }, timeoutMs);
+      this.pending.set(id, { resolve, reject, timeout });
+      this.ws.send(JSON.stringify(payload));
+    });
+  }
+
+  async navigate(url, timeoutMs = DEFAULT_NAVIGATION_TIMEOUT_MS) {
+    this.loaded = false;
+    await this.send("Page.navigate", { url });
+    await this.waitForLoad(timeoutMs);
+    const info = await this.send("Runtime.evaluate", {
+      expression: "location.href",
+      returnByValue: true
+    }).catch(() => null);
+    this.url = info?.result?.value || url;
+    return this;
+  }
+
+  async waitForLoad(timeoutMs = DEFAULT_NAVIGATION_TIMEOUT_MS) {
+    if (this.loaded) {
+      return;
+    }
+    await new Promise((resolve) => {
+      const timer = setTimeout(resolve, timeoutMs);
+      this.once("updated", () => {
+        clearTimeout(timer);
+        resolve();
+      });
+    });
+  }
+
+  async bringToFront(options = {}) {
+    if (!this.session.allowBrowserFocus && !options.force) {
+      this.session.activePageId = this.id;
+      return;
+    }
+    await this.send("Page.bringToFront").catch(() => {});
+    this.session.activePageId = this.id;
+  }
+
+  async clickAt(x, y) {
+    this.session.activePageId = this.id;
+    await this.send("Input.dispatchMouseEvent", {
+      type: "mouseMoved",
+      x,
+      y,
+      button: "none"
+    }).catch(() => {});
+    await this.send("Input.dispatchMouseEvent", {
+      type: "mousePressed",
+      x,
+      y,
+      button: "left",
+      clickCount: 1
+    });
+    await this.send("Input.dispatchMouseEvent", {
+      type: "mouseReleased",
+      x,
+      y,
+      button: "left",
+      clickCount: 1
+    });
+  }
+
+  async evaluateFunction(func, args = [], options = {}) {
+    await this.connect();
+    const allFrames = Boolean(options.allFrames);
+    const expression = `(${func.toString()})(...${JSON.stringify(args || [])})`;
+    const contexts = Array.from(this.contexts.values())
+      .filter((context) => {
+        if (!context.isDefault) {
+          return false;
+        }
+        if (allFrames) {
+          return true;
+        }
+        return !this.mainFrameId || context.frameId === this.mainFrameId;
+      });
+
+    const selectedContexts = contexts.length ? contexts : [null];
+    const results = [];
+
+    for (const context of selectedContexts) {
+      try {
+        const params = {
+          expression,
+          returnByValue: true,
+          awaitPromise: true
+        };
+        if (context?.id) {
+          params.contextId = context.id;
+        }
+        const result = await this.send("Runtime.evaluate", params, 8000);
+        results.push({ frameId: context?.frameId, result: result?.result?.value });
+      } catch (err) {
+        results.push({ frameId: context?.frameId, error: String(err?.message || err) });
+      }
+    }
+
+    return results;
+  }
+
+  async close() {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    try {
+      await requestText(`http://127.0.0.1:${this.session.port}/json/close/${encodeURIComponent(this.id)}`, {
+        timeoutMs: 2000
+      });
+    } catch {
+      try {
+        this.ws?.close();
+      } catch {
+        // ignored
+      }
+    }
+    this.session.pages.delete(this.id);
+  }
+}
+
+export class BrowserSession extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    this.port = Number(options.port || process.env.M365C_EDGE_DEBUG_PORT || DEFAULT_EDGE_PORT);
+    this.userDataDir = expandHome(options.userDataDir || defaultUserDataDir());
+    this.profileDirectory = options.profileDirectory || process.env.M365C_EDGE_PROFILE_DIRECTORY || "Default";
+    this.edgePath = findEdgeExecutable();
+    this.logger = options.logger || console;
+    this.allowBrowserFocus = options.allowBrowserFocus ?? process.env.M365C_ALLOW_BROWSER_FOCUS === "1";
+    this.process = null;
+    this.pages = new Map();
+    this.activePageId = null;
+  }
+
+  async start() {
+    if (await this.#isDebugEndpointReady()) {
+      return;
+    }
+
+    fs.mkdirSync(this.userDataDir, { recursive: true });
+    const args = [
+      `--remote-debugging-port=${this.port}`,
+      `--user-data-dir=${this.userDataDir}`,
+      `--profile-directory=${this.profileDirectory}`,
+      "--no-first-run",
+      "--no-default-browser-check",
+      "--disable-features=CalculateNativeWinOcclusion",
+      "about:blank"
+    ];
+
+    this.process = spawn(this.edgePath, args, {
+      stdio: "ignore",
+      detached: true
+    });
+    this.process.unref();
+    this.#moveBrowserToBackground();
+
+    const deadline = Date.now() + 30000;
+    while (Date.now() < deadline) {
+      if (await this.#isDebugEndpointReady()) {
+        return;
+      }
+      await sleep(500);
+    }
+
+    throw new Error(
+      `Edge CDP endpoint did not start on 127.0.0.1:${this.port}. ` +
+      `Set M365C_EDGE_PATH/M365C_EDGE_USER_DATA_DIR if your Edge install or profile is elsewhere.`
+    );
+  }
+
+  #moveBrowserToBackground() {
+    if (this.allowBrowserFocus || process.platform !== "darwin") {
+      return;
+    }
+    const script = [
+      "tell application \"System Events\"",
+      "  if exists process \"Microsoft Edge\" then",
+      "    set visible of process \"Microsoft Edge\" to false",
+      "  end if",
+      "end tell"
+    ].join("\n");
+    const child = spawn("osascript", ["-e", script], {
+      stdio: "ignore",
+      detached: true
+    });
+    child.unref();
+  }
+
+  async #isDebugEndpointReady() {
+    try {
+      await requestJson(`http://127.0.0.1:${this.port}/json/version`, { timeoutMs: 800 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async listTargets() {
+    await this.start();
+    return requestJson(`http://127.0.0.1:${this.port}/json/list`, { timeoutMs: 2000 });
+  }
+
+  async createPage(url = "about:blank", options = {}) {
+    await this.start();
+    const target = await requestJson(
+      `http://127.0.0.1:${this.port}/json/new?${encodeURIComponent(url)}`,
+      { method: "PUT", timeoutMs: 3000 }
+    );
+    const page = new CdpPage(this, target);
+    this.pages.set(page.id, page);
+    await page.connect();
+    page.on("updated", (changeInfo) => {
+      this.emit("tabUpdated", page.id, changeInfo);
+    });
+    page.on("bearer", (event) => {
+      this.emit("bearer", event);
+    });
+    if (options.active) {
+      await page.bringToFront({ force: true });
+    }
+    return page;
+  }
+
+  async getPage(id) {
+    if (this.pages.has(id)) {
+      return this.pages.get(id);
+    }
+
+    const targets = await this.listTargets();
+    const target = targets.find((row) => row.id === id);
+    if (!target?.webSocketDebuggerUrl) {
+      return null;
+    }
+    const page = new CdpPage(this, target);
+    this.pages.set(page.id, page);
+    await page.connect();
+    page.on("updated", (changeInfo) => {
+      this.emit("tabUpdated", page.id, changeInfo);
+    });
+    page.on("bearer", (event) => {
+      this.emit("bearer", event);
+    });
+    return page;
+  }
+
+  async findPage(predicate) {
+    const targets = await this.listTargets();
+    const target = targets.find((row) => row.type === "page" && predicate(row));
+    if (!target?.id) {
+      return null;
+    }
+    return this.getPage(target.id);
+  }
+
+  async getChildFramePages(parentId) {
+    const targets = await this.listTargets();
+    const children = [];
+    const queue = [parentId];
+    const seen = new Set(queue);
+
+    while (queue.length) {
+      const currentParentId = queue.shift();
+      for (const target of targets) {
+        if (target.type !== "iframe" || target.parentId !== currentParentId || !target.webSocketDebuggerUrl) {
+          continue;
+        }
+        if (seen.has(target.id)) {
+          continue;
+        }
+        seen.add(target.id);
+        queue.push(target.id);
+        const page = await this.getPage(target.id);
+        if (page) {
+          children.push(page);
+        }
+      }
+    }
+
+    return children;
+  }
+}
+
+export function installChromeShim(browserSession) {
+  const listeners = new Set();
+
+  browserSession.on("tabUpdated", (tabId, changeInfo) => {
+    for (const listener of listeners) {
+      try {
+        listener(tabId, changeInfo);
+      } catch {
+        // ignored
+      }
+    }
+  });
+
+  globalThis.chrome = {
+    tabs: {
+      async create({ url = "about:blank", active = false } = {}) {
+        const page = await browserSession.createPage(url, { active });
+        return { id: page.id, url: page.url, status: page.loaded ? "complete" : "loading" };
+      },
+      async remove(tabId) {
+        const page = await browserSession.getPage(tabId);
+        await page?.close();
+      },
+      async update(tabId, updateProperties = {}) {
+        const page = await browserSession.getPage(tabId);
+        if (!page) {
+          throw new Error(`Tab not found: ${tabId}`);
+        }
+        if (updateProperties.url) {
+          await page.navigate(updateProperties.url);
+        }
+        if (updateProperties.active) {
+          await page.bringToFront({ force: true });
+        }
+        return { id: page.id, url: page.url, status: page.loaded ? "complete" : "loading" };
+      },
+      async query(queryInfo = {}) {
+        if (queryInfo.active) {
+          const page = browserSession.activePageId
+            ? await browserSession.getPage(browserSession.activePageId)
+            : null;
+          return page ? [{ id: page.id, url: page.url, status: page.loaded ? "complete" : "loading" }] : [];
+        }
+        const targets = await browserSession.listTargets();
+        return targets
+          .filter((target) => target.type === "page")
+          .map((target) => ({ id: target.id, url: target.url, status: "complete" }));
+      },
+      async get(tabId) {
+        const page = await browserSession.getPage(tabId);
+        if (!page) {
+          throw new Error(`Tab not found: ${tabId}`);
+        }
+        return { id: page.id, url: page.url, status: page.loaded ? "complete" : "loading" };
+      },
+      onUpdated: {
+        addListener(listener) {
+          listeners.add(listener);
+        },
+        removeListener(listener) {
+          listeners.delete(listener);
+        }
+      }
+    },
+    scripting: {
+      async executeScript({ target, func, args = [] } = {}) {
+        const page = await browserSession.getPage(target?.tabId);
+        if (!page) {
+          throw new Error(`Tab not found: ${target?.tabId}`);
+        }
+        const allFrames = Boolean(target?.allFrames);
+        const results = await page.evaluateFunction(func, args, { allFrames });
+        if (!allFrames) {
+          return results;
+        }
+
+        const framePages = await browserSession.getChildFramePages(page.id);
+        for (const framePage of framePages) {
+          const frameResults = await framePage.evaluateFunction(func, args, { allFrames: false });
+          results.push(...frameResults);
+        }
+        return results;
+      }
+    }
+  };
+}

package/src/index.js

@@ -7,7 +7,10 @@ import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { createMcpExpressApp } from "@modelcontextprotocol/sdk/server/express.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
-import { WsServer } from "./ws-server.js";
+import { SearchApi } from "./lib/search-api.js";
+import { ContentReader } from "./lib/content-reader.js";
+import { BrowserSession, installChromeShim } from "./browser-session.js";
+import { GraphTokenProvider, ServerTokenManager, SubstrateTokenProvider, TOKEN_AUDIENCES } from "./token-providers.js";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const PKG = JSON.parse(fs.readFileSync(path.resolve(__dirname, "..", "package.json"), "utf-8"));
@@ -18,7 +21,6 @@ const SERVER_INFO = {
 };
 
 const DEFAULT_MCP_PORT = 52366;
-const DEFAULT_WS_PORT = 52365;
 const SESSION_IDLE_TTL_MS = 30 * 60 * 1000;
 const SESSION_SWEEP_INTERVAL_MS = 5 * 60 * 1000;
 
@@ -282,7 +284,6 @@ function sendJsonRpcError(res, status, code, message) {
 
 async function main() {
   const mcpPort = parsePort(process.env.M365C_MCP_PORT, "M365C_MCP_PORT", DEFAULT_MCP_PORT);
-  const wsPort = parsePort(process.env.M365C_WS_PORT, "M365C_WS_PORT", DEFAULT_WS_PORT);
 
   // MCP responses are returned over HTTP; operational logs must go to stderr only.
   const stderrLogger = {
@@ -294,15 +295,37 @@ async function main() {
   const readHandleCache = createReadHandleCache();
   const tempFiles = createTempFileManager(stderrLogger);
 
-  const ws = new WsServer({
-    host: "127.0.0.1",
-    port: wsPort,
+  const browserSession = new BrowserSession({
     logger: stderrLogger
   });
-  await ws.start();
+  installChromeShim(browserSession);
+
+  const tokenManager = new ServerTokenManager({
+    logger: stderrLogger
+  });
+  const substrateTokenProvider = new SubstrateTokenProvider(browserSession, tokenManager, {
+    logger: stderrLogger
+  });
+  const graphTokenProvider = new GraphTokenProvider(browserSession, {
+    logger: stderrLogger,
+    tokenManager
+  });
+  const searchApi = new SearchApi(tokenManager, {
+    onAuthError: () => substrateTokenProvider.refresh()
+  });
+  const contentReader = new ContentReader(graphTokenProvider, stderrLogger);
 
   const toolRegistry = new ToolRegistry();
-  const toolContext = { ws, readHandleCache, tempFiles };
+  const toolContext = {
+    readHandleCache,
+    tempFiles,
+    searchApi,
+    contentReader,
+    substrateTokenProvider,
+    graphTokenProvider,
+    tokenManager,
+    tokenAudiences: TOKEN_AUDIENCES
+  };
   await loadToolModules(toolRegistry, toolContext);
 
   const sessions = new Map();
@@ -404,12 +427,6 @@ async function main() {
       }
     }
 
-    try {
-      await ws.stop();
-    } catch (err) {
-      stderrLogger.warn("[m365connector] failed to stop WebSocket server:", err);
-    }
-
     tempFiles.cleanup();
 
     await new Promise((resolve) => {