m365connector 0.3.3 → 0.3.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "m365connector",
-  "version": "0.3.3",
+  "version": "0.3.5",
   "description": "MCP server for M365 Connector browser extension",
   "type": "module",
   "main": "src/index.js",

package/src/index.js

@@ -1,5 +1,6 @@
 import crypto from "node:crypto";
 import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
@@ -65,6 +66,126 @@ function createReadHandleCache() {
   return cache;
 }
 
+const TEMP_FILE_TTL_MS = 30 * 60 * 1000;
+
+function createTempFileManager(logger) {
+  const rootDir = path.join(os.tmpdir(), "m365c-open");
+
+  // Validate shared root: reject symlinks, non-directories, or foreign-owned dirs
+  try {
+    const rootStat = fs.lstatSync(rootDir);
+    if (rootStat.isSymbolicLink()) {
+      fs.unlinkSync(rootDir);
+      logger.warn("[m365connector] removed symlink at temp root:", rootDir);
+    } else if (rootStat.isFile()) {
+      fs.unlinkSync(rootDir);
+      logger.warn("[m365connector] removed regular file at temp root:", rootDir);
+    } else if (!rootStat.isDirectory()) {
+      throw new Error(`Unsafe temp root type at ${rootDir} (not a directory, symlink, or file)`);
+    } else {
+      // Verify directory ownership on POSIX
+      const uid = typeof process.getuid === "function" ? process.getuid() : null;
+      if (uid != null && rootStat.uid !== uid) {
+        throw new Error(`Unsafe temp root owner at ${rootDir} (owned by uid ${rootStat.uid}, expected ${uid})`);
+      }
+    }
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      throw err;
+    }
+  }
+
+  // Create shared root for stale file sweeps across processes
+  try {
+    fs.mkdirSync(rootDir, { recursive: true, mode: 0o700 });
+  } catch {
+    // Root may be owned by another user; sweep will be skipped below
+  }
+
+  // Sweep stale files/dirs from previous crashed processes on startup
+  try {
+    for (const entry of fs.readdirSync(rootDir)) {
+      const entryPath = path.join(rootDir, entry);
+      try {
+        const stat = fs.statSync(entryPath);
+        if (Date.now() - stat.mtimeMs > TEMP_FILE_TTL_MS) {
+          if (stat.isDirectory()) {
+            for (const f of fs.readdirSync(entryPath)) {
+              try { fs.unlinkSync(path.join(entryPath, f)); } catch {}
+            }
+            fs.rmdirSync(entryPath);
+          } else {
+            fs.unlinkSync(entryPath);
+          }
+        }
+      } catch (err) {
+        logger.warn("[m365connector] failed to sweep stale temp entry:", entryPath, err.message);
+      }
+    }
+  } catch (err) {
+    logger.warn("[m365connector] failed to read temp root for cleanup:", err.message);
+  }
+
+  // Create process-owned subdirectory — immune to pre-creation attacks
+  const baseDir = fs.mkdtempSync(path.join(rootDir, "proc-"));
+  fs.chmodSync(baseDir, 0o700);
+
+  const tracked = new Map(); // filePath → expiresAt
+
+  const interval = setInterval(() => {
+    const now = Date.now();
+    for (const [filePath, expiresAt] of tracked.entries()) {
+      if (expiresAt < now) {
+        tracked.delete(filePath);
+        fs.unlink(filePath, (err) => {
+          if (err && err.code !== "ENOENT") {
+            logger.warn("[m365connector] failed to delete temp file:", filePath, err.message);
+          }
+        });
+      }
+    }
+  }, 60_000);
+  interval.unref();
+
+  function ensureDir() {
+    try {
+      fs.mkdirSync(baseDir, { recursive: true, mode: 0o700 });
+      fs.chmodSync(baseDir, 0o700);
+    } catch (err) {
+      logger.warn("[m365connector] failed to ensure temp directory:", err.message);
+      throw err;
+    }
+  }
+
+  return {
+    write(content) {
+      ensureDir();
+      const fileName = `${crypto.randomUUID()}.txt`;
+      const filePath = path.join(baseDir, fileName);
+      fs.writeFileSync(filePath, content, { encoding: "utf-8", mode: 0o600, flag: "wx" });
+      tracked.set(filePath, Date.now() + TEMP_FILE_TTL_MS);
+      return filePath;
+    },
+    cleanup() {
+      clearInterval(interval);
+      for (const filePath of tracked.keys()) {
+        try {
+          fs.unlinkSync(filePath);
+        } catch (err) {
+          if (err.code !== "ENOENT") {
+            logger.warn("[m365connector] failed to delete temp file:", filePath, err.message);
+          }
+        }
+      }
+      tracked.clear();
+      // Remove the per-process directory itself
+      try {
+        fs.rmdirSync(baseDir);
+      } catch {}
+    }
+  };
+}
+
 async function loadToolModules(toolRegistry, context) {
   const toolsDir = path.resolve(__dirname, "tools");
   const files = fs
@@ -171,6 +292,7 @@ async function main() {
   };
 
   const readHandleCache = createReadHandleCache();
+  const tempFiles = createTempFileManager(stderrLogger);
 
   const ws = new WsServer({
     host: "127.0.0.1",
@@ -180,7 +302,7 @@ async function main() {
   await ws.start();
 
   const toolRegistry = new ToolRegistry();
-  const toolContext = { ws, readHandleCache };
+  const toolContext = { ws, readHandleCache, tempFiles };
   await loadToolModules(toolRegistry, toolContext);
 
   const sessions = new Map();
@@ -288,6 +410,8 @@ async function main() {
       stderrLogger.warn("[m365connector] failed to stop WebSocket server:", err);
     }
 
+    tempFiles.cleanup();
+
     await new Promise((resolve) => {
       httpServer.close(() => resolve());
     });

package/src/tools/search.js

@@ -50,7 +50,7 @@ const SEARCH_TOOL = {
 const OPEN_TOOL = {
   name: "open",
   description:
-    "Open and read best-effort content for a prior search result using its read handle. Returns completeness metadata: full, partial, or snippet.",
+    "Open and read content for a prior search result. Returns a summary with metadata. Small content is returned inline in the 'content' field. Large content is saved to a local temp file — use the returned file_path with your file-reading tool to access the content.",
   inputSchema: {
     type: "object",
     properties: {
@@ -333,10 +333,72 @@ export function registerTools(registry, context) {
     const wsResult = await context.ws.sendRequest(
       "open",
       { conversation_id: conversationId, context: readContext, fullContent: Boolean(args.fullContent) },
-      { timeoutMs: 60000 }
+      { timeoutMs: args.fullContent ? 90000 : 60000 }
     );
 
-    return asObject(wsResult);
+    const result = asObject(wsResult);
+    if (!Object.hasOwn(result, "content")) {
+      throw new Error("Extension response missing content for this item.");
+    }
+    const content = typeof result.content === "string"
+      ? result.content
+      : (result.content != null ? JSON.stringify(result.content, null, 2) : "");
+    const contentBytes = Buffer.byteLength(content, "utf-8");
+
+    const FILE_THRESHOLD = 4096;
+    const useFile = contentBytes > FILE_THRESHOLD;
+
+    const summary = {
+      type: readContext.type || result.type || "",
+      title: readContext.title || result.title || "",
+      url: readContext.url || result.url || "",
+      snippet: readContext.snippet || "",
+      completeness: result.completeness || "unknown"
+    };
+
+    if (useFile) {
+      summary.file_path = context.tempFiles.write(content);
+      summary.file_size_bytes = contentBytes;
+    } else {
+      summary.content = content;
+    }
+
+    // Carry over key metadata from readContext and result.metadata
+    // Email _readContext has no metadata object; fields may be at readContext top level.
+    // Content reader returns result.metadata with additional fields.
+    const meta = { ...asObject(readContext.metadata), ...asObject(result.metadata) };
+    if (readContext.type === "email") {
+      const from = meta.from || readContext.from;
+      // Graph returns toRecipients (array of strings or {emailAddress} objects) and receivedDateTime
+      const rawTo = meta.toRecipients || meta.to || readContext.to;
+      const to = Array.isArray(rawTo)
+        ? rawTo.map((r) => (typeof r === "string" ? r : (r?.emailAddress?.address || r?.emailAddress?.name || String(r)))).join(", ")
+        : rawTo;
+      const subject = meta.subject || readContext.subject;
+      const date = meta.receivedDateTime || meta.date || readContext.date;
+      if (from) summary.from = from;
+      if (to) summary.to = to;
+      if (subject) summary.subject = subject;
+      if (date) summary.date = date;
+    } else if (readContext.type === "file") {
+      if (meta.author) summary.author = meta.author;
+      if (meta.fileType) summary.fileType = meta.fileType;
+    } else if (readContext.type === "chat") {
+      if (meta.from) summary.from = meta.from;
+      if (meta.teamName) summary.teamName = meta.teamName;
+      if (meta.channelName) summary.channelName = meta.channelName;
+    } else if (readContext.type === "event") {
+      if (meta.location) summary.location = meta.location;
+      if (meta.startTime) summary.startTime = meta.startTime;
+      if (meta.endTime) summary.endTime = meta.endTime;
+      if (meta.organizer) summary.organizer = meta.organizer;
+    }
+
+    if (result.warning) {
+      summary.warning = result.warning;
+    }
+
+    return summary;
   });
 
   registry.addTool(WHOAMI_TOOL, async (args) => {

package/src/ws-server.js

@@ -44,7 +44,7 @@ export class WsServer {
       this.wss.once("error", reject);
     });
 
-    this.logger.error(`[m365connector/ws] listening on ws://${this.host}:${this.port}`);
+    this.logger.info(`[m365connector/ws] listening on ws://${this.host}:${this.port}`);
   }
 
   async stop() {
@@ -96,6 +96,7 @@ export class WsServer {
 
     return new Promise((resolve, reject) => {
       const timeout = setTimeout(() => {
+        this.logger.warn(`[m365connector/ws] request timed out: type=${type} id=${id}`);
         this.pending.delete(id);
         reject(new Error(`WebSocket request timed out after ${timeoutMs}ms`));
       }, timeoutMs);
@@ -130,7 +131,7 @@ export class WsServer {
     if (this.client && this.client.readyState === WebSocket.OPEN) {
       // MV3 service workers can die silently without sending a close frame.
       // When the extension reconnects, replace the stale connection.
-      this.logger.error("[m365connector/ws] replacing existing connection with new one");
+      this.logger.info("[m365connector/ws] replacing existing connection with new one");
       try { this.client.terminate(); } catch (_e) { /* ignored */ }
       this.handleClose(this.client);
     }
@@ -147,14 +148,14 @@ export class WsServer {
     });
 
     socket.on("close", (code, reason) => {
-      this.logger.error(`[m365connector/ws] socket close: code=${code}, reason=${String(reason)}`);
+      this.logger.info(`[m365connector/ws] socket close: code=${code}, reason=${String(reason)}`);
       this.handleClose(socket);
     });
 
     socket.on("error", (err) => {
       this.logger.warn("[m365connector/ws] client socket error:", err.message);
     });
-    this.logger.error("[m365connector/ws] extension connected");
+    this.logger.info("[m365connector/ws] extension connected");
   }
 
   async handleMessage(socket, rawData) {
@@ -197,6 +198,6 @@ export class WsServer {
       this.pending.delete(id);
     }
 
-    this.logger.error("[m365connector/ws] extension disconnected");
+    this.logger.info("[m365connector/ws] extension disconnected");
   }
 }