test(mcp): make process-tree + idmap tests deterministic across OSes

Two pre-existing tests only failed on CI (which never ran tests before — install died on
the lockfile), one per platform:

- findProfileBrowserPids (Linux): readProcessArgs read the runner's REAL /proc first, so
  the fake PIDs 55/66/77 resolved to kernel threads with EMPTY cmdlines and the mocked `ps`
  path was unreachable → []. Make the /proc reader injectable (production default unchanged)
  and have the posix test pass readProc:()=>null to force the `ps` mock.
- latestDiffId (Windows): coarse NTFS mtime resolution stamps two same-tick saves
  identically, so d2 wasn't > d1. Backdate d1 with utimesSync so d2 is unambiguously newer
  (mirrors production, where diffs are saved seconds/minutes apart).

macos CI was already green; these close the ubuntu + windows gaps.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: ARHAEEM

packages/mcp-server/src/process-tree.js

@@ -87,7 +87,7 @@ async function collectDescendantPids(rootPid, exec) {
  */
 export async function findProfileBrowserPids(
   userDataDir,
-  { platform = process.platform, exec = execFile } = {},
+  { platform = process.platform, exec = execFile, readProc } = {},
 ) {
   const marker = `--user-data-dir=${userDataDir}`;
 
@@ -133,32 +133,40 @@ export async function findProfileBrowserPids(
       return [];
     }
   }
-  return filterRootBrowserPids(pids, exec);
+  return filterRootBrowserPids(pids, exec, readProc);
 }
 
 /**
  * Drop Chromium helper processes (`--type=...`) so we only kill root browsers.
  * Linux: /proc/<pid>/cmdline. macOS/BSD: ps -p <pid> -o args=.
  */
-async function filterRootBrowserPids(pids, exec) {
+async function filterRootBrowserPids(pids, exec, readProc = readProcCmdline) {
   const roots = [];
   for (const pid of pids) {
-    const args = await readProcessArgs(pid, exec);
+    const args = await readProcessArgs(pid, exec, readProc);
     if (!args) continue;
     if (args.includes('--type=')) continue;
     roots.push(pid);
   }
   return roots;
 }
 
-async function readProcessArgs(pid, exec) {
-  // Prefer /proc on Linux (no shell).
+// Default /proc reader (Linux fast-path, no shell). Returns the space-joined cmdline (may be '' for
+// a kernel thread), or null when /proc is unavailable (not Linux / pid gone) so the caller falls
+// back to `ps`. Injectable so tests can bypass the runner's REAL /proc (whose low PIDs 55/66/77 are
+// kernel threads with empty cmdlines — that made the mocked `ps` path unreachable and the test fail
+// only on Linux CI).
+function readProcCmdline(pid) {
   try {
-    const raw = readFileSync(`/proc/${pid}/cmdline`, 'utf8');
-    return raw.replace(/\0/g, ' ');
+    return readFileSync(`/proc/${pid}/cmdline`, 'utf8').replace(/\0/g, ' ');
   } catch {
-    // not Linux or pid gone
+    return null;
   }
+}
+
+async function readProcessArgs(pid, exec, readProc = readProcCmdline) {
+  const fromProc = readProc(pid);
+  if (fromProc != null) return fromProc;
   try {
     const { stdout } = await exec('ps', ['-p', String(pid), '-o', 'args='], { timeout: 5_000 });
     return String(stdout || '');

packages/mcp-server/test/sync/test-idmap.test.js

@@ -1,7 +1,7 @@
 import { describe, it } from 'node:test';
 import assert from 'node:assert/strict';
 import { join } from 'node:path';
-import { mkdtempSync, existsSync } from 'node:fs';
+import { mkdtempSync, existsSync, utimesSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { matchByName, saveIdmap, loadIdmap, syncDir, saveDiff, loadDiff, latestDiffId } from '../../src/sync/idmap.js';
 
@@ -81,6 +81,11 @@ describe('idmap diff I/O', () => {
   it('latestDiffId returns the id of the most recently saved diff', () => {
     process.env.AIRTABLE_USER_MCP_HOME = mkdtempSync(join(tmpdir(), 'sync-diff-test-'));
     saveDiff(SRC, DEST, { diffId: 'd1', tables: [] });
+    // Coarse FS mtime resolution (Windows/NTFS) stamps two same-tick writes identically, so
+    // latestDiffId's mtime compare can't tell d2 from d1. Backdate d1 so d2 is unambiguously
+    // newer — mirrors production, where diffs are saved seconds/minutes apart.
+    const past = new Date(Date.now() - 5000);
+    utimesSync(join(syncDir(SRC, DEST), 'diff-d1.json'), past, past);
     assert.equal(latestDiffId(SRC, DEST), 'd1');
     // Save a second diff later — it should win
     saveDiff(SRC, DEST, { diffId: 'd2', tables: ['x'] });

packages/mcp-server/test/test-process-tree.test.js

@@ -75,6 +75,9 @@ describe("findProfileBrowserPids", () => {
     const pids = await findProfileBrowserPids("/home/u/.chrome-profile", {
       platform: "linux",
       exec: (f, a, o) => s.exec(f, a, o),
+      // Force the mocked `ps` path: on real Linux CI, /proc/55|66|77/cmdline are kernel threads
+      // with EMPTY cmdlines, which would bypass the mock and make this test fail only on Linux.
+      readProc: () => null,
     });
     assert.deepEqual(pids, [55]);
     assert.equal(s.calls[0].file, "pgrep");