cross-agent-teams-mcp 0.5.10 → 0.5.12

package/dist/cli.d.ts

@@ -6,6 +6,7 @@ interface DaemonCliArgs {
     requestedPort: number;
     host: string;
     localDevice: string;
+    loopbackCompanion: boolean;
 }
 declare function parseDaemonCliArgs(argv?: readonly string[], env?: NodeJS.ProcessEnv): DaemonCliArgs;
 

package/dist/cli.js

@@ -8,6 +8,7 @@ import { fileURLToPath } from "url";
 
 // src/daemon/server.ts
 import Fastify from "fastify";
+import { createServer as createHttpServer } from "http";
 
 // src/storage/db.ts
 import Database from "better-sqlite3";
@@ -3712,12 +3713,14 @@ function mountMcp(app, db, fanout, channelWakeFanout, opts = {}) {
       sessionIdGenerator: () => randomUUID5(),
       onsessioninitialized: (sid) => {
         sessionIdForCaller = sid;
+        const now2 = Date.now();
         sessions.set(sid, {
           transport,
           server,
           sessionId: sid,
           agentIdHolder,
-          createdAt: Date.now(),
+          createdAt: now2,
+          lastActivityAt: now2,
           clientInfo: void 0,
           originInfo: { origin: "local", remote_addr: null }
         });
@@ -3771,12 +3774,14 @@ function mountMcp(app, db, fanout, channelWakeFanout, opts = {}) {
       registerSvc
     );
     server.connect(transport);
+    const now = Date.now();
     return {
       transport,
       server,
       sessionId: "",
       agentIdHolder,
-      createdAt: Date.now(),
+      createdAt: now,
+      lastActivityAt: now,
       originInfo: { origin: "local", remote_addr: null }
     };
   }
@@ -3820,6 +3825,7 @@ function mountMcp(app, db, fanout, channelWakeFanout, opts = {}) {
     }
     if (session) {
       session.originInfo = originInfo;
+      session.lastActivityAt = Date.now();
     }
     if (body?.method === "initialize") {
       const params = body.params;
@@ -3842,6 +3848,7 @@ function mountMcp(app, db, fanout, channelWakeFanout, opts = {}) {
     const sid = req.headers["mcp-session-id"];
     const session = sid ? sessions.get(sid) : void 0;
     if (!session) return reply.code(400).send({ error: "unknown_session" });
+    session.lastActivityAt = Date.now();
     await session.transport.handleRequest(req.raw, reply.raw);
     return reply;
   });
@@ -3849,14 +3856,15 @@ function mountMcp(app, db, fanout, channelWakeFanout, opts = {}) {
     const sid = req.headers["mcp-session-id"];
     const session = sid ? sessions.get(sid) : void 0;
     if (!session) return reply.code(400).send({ error: "unknown_session" });
+    session.lastActivityAt = Date.now();
     await session.transport.handleRequest(req.raw, reply.raw);
     return reply;
   });
-  function reapOrphanSessions(now, graceMs = 6e4) {
+  function reapOrphanSessions(now, graceMs = 18e5) {
     for (const session of sessions.values()) {
       if (session.agentIdHolder.current !== void 0) continue;
-      const ageMs = now - session.createdAt;
-      if (ageMs < graceMs) continue;
+      const idleMs = now - session.lastActivityAt;
+      if (idleMs < graceMs) continue;
       try {
         void session.transport.close();
       } catch {
@@ -4036,10 +4044,14 @@ function classifyPeerAddress(address) {
 function isLoopbackHost(host) {
   return host === "localhost" || isLoopbackAddress(host);
 }
+function bindHostCoversIpv4Loopback(host) {
+  return host === "127.0.0.1" || host === "localhost" || host === "0.0.0.0";
+}
 
 // src/daemon/server.ts
 var DEFAULT_KEEP_ALIVE_TIMEOUT_MS = 12e4;
 var DEFAULT_ORPHAN_GC_INTERVAL_MS = 6e4;
+var DEFAULT_ORPHAN_GC_IDLE_MS = 18e5;
 function parsePositiveInt(raw, fallback) {
   const n = Number(raw);
   return Number.isInteger(n) && n > 0 ? n : fallback;
@@ -4073,9 +4085,10 @@ async function buildServer(opts) {
   }, cleanupIntervalMs);
   if (typeof interval.unref === "function") interval.unref();
   const orphanGcIntervalMs = opts.orphanGcIntervalMs ?? parsePositiveInt(process.env.ORPHAN_GC_INTERVAL_MS, DEFAULT_ORPHAN_GC_INTERVAL_MS);
+  const orphanGcIdleMs = opts.orphanGcIdleMs ?? parsePositiveInt(process.env.ORPHAN_GC_IDLE_MS, DEFAULT_ORPHAN_GC_IDLE_MS);
   const orphanGcInterval = setInterval(() => {
     try {
-      mcp.reapOrphanSessions(Date.now());
+      mcp.reapOrphanSessions(Date.now(), orphanGcIdleMs);
     } catch {
     }
   }, orphanGcIntervalMs);
@@ -4092,10 +4105,46 @@ async function buildServer(opts) {
 async function startServer(opts) {
   const app = await buildServer(opts);
   const host = opts.host ?? "127.0.0.1";
+  const companionRef = { server: void 0 };
+  app.addHook("onClose", async () => {
+    const server = companionRef.server;
+    if (!server) return;
+    await new Promise((resolve) => {
+      server.close(() => resolve());
+    });
+  });
   await app.listen({ port: opts.port, host });
   const addr = app.server.address();
   const port = addr && typeof addr === "object" ? addr.port : opts.port;
-  return { app, port, host };
+  const companionEnabled = opts.loopbackCompanion !== false;
+  if (companionEnabled && !bindHostCoversIpv4Loopback(host)) {
+    const handler = app.server.listeners("request")[0];
+    if (!handler) {
+      await app.close();
+      throw new Error("loopback_companion_no_handler: Fastify did not expose a request handler");
+    }
+    const companion = createHttpServer(handler);
+    try {
+      await new Promise((resolve, reject) => {
+        const onErr = (err) => reject(err);
+        companion.once("error", onErr);
+        companion.listen(port, "127.0.0.1", () => {
+          companion.removeListener("error", onErr);
+          resolve();
+        });
+      });
+    } catch (err) {
+      try {
+        companion.close();
+      } catch {
+      }
+      await app.close();
+      const detail = err instanceof Error ? err.message : String(err);
+      throw new Error(`loopback_companion_bind_failed: ${detail}`);
+    }
+    companionRef.server = companion;
+  }
+  return { app, port, host, loopbackCompanion: companionRef.server };
 }
 
 // src/daemon/pid.ts
@@ -4130,17 +4179,76 @@ function releasePidFile(path) {
 }
 
 // src/daemon/shutdown.ts
-function wireShutdown(app, pidPath) {
-  const handler = async (_signal) => {
+var DEFAULT_GRACE_MS = 5e3;
+function resolveGraceMs(explicit) {
+  if (typeof explicit === "number" && Number.isFinite(explicit)) {
+    return explicit < 0 ? 0 : Math.floor(explicit);
+  }
+  const raw = process.env.XATS_SHUTDOWN_GRACE_MS;
+  if (raw === void 0 || raw === "") return DEFAULT_GRACE_MS;
+  const n = Number(raw);
+  if (!Number.isFinite(n)) return DEFAULT_GRACE_MS;
+  return n < 0 ? 0 : Math.floor(n);
+}
+function wireShutdown(app, pidPath, opts = {}) {
+  const graceMs = resolveGraceMs(opts.graceMs);
+  const exit = opts.exit ?? ((code) => {
+    process.exit(code);
+  });
+  const extraForceClose = opts.extraForceClose;
+  let shuttingDown = false;
+  const handler = (_signal) => {
+    if (shuttingDown) {
+      releasePidFile(pidPath);
+      exit(0);
+      return;
+    }
+    shuttingDown = true;
+    void runDrain(app, pidPath, graceMs, exit, extraForceClose);
+  };
+  process.on("SIGTERM", handler);
+  process.on("SIGINT", handler);
+}
+function forceCloseAll(app, extra) {
+  try {
+    app.server.closeAllConnections();
+  } catch {
+  }
+  if (extra) {
+    try {
+      extra();
+    } catch {
+    }
+  }
+}
+async function runDrain(app, pidPath, graceMs, exit, extraForceClose) {
+  if (graceMs <= 0) {
+    forceCloseAll(app, extraForceClose);
     try {
       await app.close();
     } catch {
     }
     releasePidFile(pidPath);
-    process.exit(0);
-  };
-  process.once("SIGTERM", handler);
-  process.once("SIGINT", handler);
+    exit(0);
+    return;
+  }
+  let timer;
+  const deadline = new Promise((resolve) => {
+    timer = setTimeout(() => resolve("timeout"), graceMs);
+    if (typeof timer.unref === "function") timer.unref();
+  });
+  const closed = app.close().then(() => "closed").catch(() => "closed");
+  const winner = await Promise.race([closed, deadline]);
+  if (winner === "timeout") {
+    forceCloseAll(app, extraForceClose);
+    try {
+      await app.close();
+    } catch {
+    }
+  }
+  if (timer) clearTimeout(timer);
+  releasePidFile(pidPath);
+  exit(0);
 }
 
 // src/daemon/port.ts
@@ -4179,13 +4287,15 @@ function parseDaemonCliArgs(argv = process.argv, env = process.env) {
     const host = parseArg("--host", "127.0.0.1") ?? "127.0.0.1";
     const localDevice = resolveLocalDeviceLabel(parseArg("--device"));
     const requestedPort = Number(parseArg("--port", "9100"));
+    const loopbackCompanion = !process.argv.includes("--no-loopback-companion");
     return {
       pidPath: parseArg("--pid-file", join(home, "daemon.pid")),
       dbPath: parseArg("--db", join(home, "data.db")),
       token,
       requestedPort,
       host,
-      localDevice
+      localDevice,
+      loopbackCompanion
     };
   } finally {
     process.argv = originalArgv;
@@ -4209,10 +4319,20 @@ async function runDaemon() {
     token: args.token,
     port,
     host: args.host,
-    localDevice: args.localDevice
+    localDevice: args.localDevice,
+    loopbackCompanion: args.loopbackCompanion
+  });
+  const companion = started.loopbackCompanion;
+  wireShutdown(started.app, args.pidPath, {
+    extraForceClose: companion ? () => {
+      try {
+        companion.closeAllConnections();
+      } catch {
+      }
+    } : void 0
   });
-  wireShutdown(started.app, args.pidPath);
-  console.log(`listening on ${started.host}:${started.port} device=${args.localDevice}`);
+  const companionSuffix = companion ? ` (+ 127.0.0.1:${started.port} loopback companion)` : "";
+  console.log(`listening on ${started.host}:${started.port}${companionSuffix} device=${args.localDevice}`);
 }
 function resolveDaemonPort(explicit) {
   if (explicit !== void 0) {