@optave/codegraph 3.5.0 → 3.6.0

package/src/graph/algorithms/leiden/partition.ts

@@ -56,6 +56,109 @@ function u8get(a: Uint8Array, i: number): number {
   return a[i] as number;
 }
 
+/**
+ * Accumulate per-community node-level totals (size, count, strength) into the
+ * provided aggregate arrays. Both `initializeAggregates` and `compactCommunityIds`
+ * share this logic — extracting it eliminates the duplication.
+ */
+function accumulateNodeAggregates(
+  graph: GraphAdapter,
+  nodeCommunity: Int32Array,
+  n: number,
+  totalSize: Float64Array,
+  nodeCount: Int32Array,
+  internalEdgeWeight: Float64Array,
+  totalStrength: Float64Array,
+  totalOutStrength: Float64Array,
+  totalInStrength: Float64Array,
+): void {
+  for (let i = 0; i < n; i++) {
+    const c: number = iget(nodeCommunity, i);
+    totalSize[c] = fget(totalSize, c) + fget(graph.size, i);
+    nodeCount[c] = iget(nodeCount, c) + 1;
+    if (graph.directed) {
+      totalOutStrength[c] = fget(totalOutStrength, c) + fget(graph.strengthOut, i);
+      totalInStrength[c] = fget(totalInStrength, c) + fget(graph.strengthIn, i);
+    } else {
+      totalStrength[c] = fget(totalStrength, c) + fget(graph.strengthOut, i);
+    }
+    if (fget(graph.selfLoop, i) !== 0)
+      internalEdgeWeight[c] = fget(internalEdgeWeight, c) + fget(graph.selfLoop, i);
+  }
+}
+
+/**
+ * Accumulate intra-community edge weights. For directed graphs, counts all
+ * intra-community non-self edges. For undirected, counts each edge once (j > i).
+ */
+function accumulateInternalEdgeWeights(
+  graph: GraphAdapter,
+  nodeCommunity: Int32Array,
+  n: number,
+  internalEdgeWeight: Float64Array,
+): void {
+  if (graph.directed) {
+    for (let i = 0; i < n; i++) {
+      const ci: number = iget(nodeCommunity, i);
+      const neighbors = graph.outEdges[i]!;
+      for (let k = 0; k < neighbors.length; k++) {
+        const { to: j, w } = neighbors[k]!;
+        if (i === j) continue; // self-loop already counted via graph.selfLoop[i]
+        if (ci === iget(nodeCommunity, j))
+          internalEdgeWeight[ci] = fget(internalEdgeWeight, ci) + w;
+      }
+    }
+  } else {
+    for (let i = 0; i < n; i++) {
+      const ci: number = iget(nodeCommunity, i);
+      const neighbors = graph.outEdges[i]!;
+      for (let k = 0; k < neighbors.length; k++) {
+        const { to: j, w } = neighbors[k]!;
+        if (j <= i) continue;
+        if (ci === iget(nodeCommunity, j))
+          internalEdgeWeight[ci] = fget(internalEdgeWeight, ci) + w;
+      }
+    }
+  }
+}
+
+/**
+ * Sort community IDs according to the compaction options: preserve original
+ * order, respect a user-provided label map, or sort by descending size.
+ * Returns the sorted list of non-empty community IDs.
+ */
+function buildSortedCommunityIds(
+  ids: number[],
+  opts: CompactOptions,
+  communityTotalSize: Float64Array,
+  communityNodeCount: Int32Array,
+): void {
+  if (opts.keepOldOrder) {
+    ids.sort((a, b) => a - b);
+  } else if (opts.preserveMap instanceof Map) {
+    const preserveMap = opts.preserveMap;
+    ids.sort((a, b) => {
+      const pa = preserveMap.get(a);
+      const pb = preserveMap.get(b);
+      if (pa != null && pb != null && pa !== pb) return pa - pb;
+      if (pa != null && pb == null) return -1;
+      if (pb != null && pa == null) return 1;
+      return (
+        fget(communityTotalSize, b) - fget(communityTotalSize, a) ||
+        iget(communityNodeCount, b) - iget(communityNodeCount, a) ||
+        a - b
+      );
+    });
+  } else {
+    ids.sort(
+      (a, b) =>
+        fget(communityTotalSize, b) - fget(communityTotalSize, a) ||
+        iget(communityNodeCount, b) - iget(communityNodeCount, a) ||
+        a - b,
+    );
+  }
+}
+
 export function makePartition(graph: GraphAdapter): Partition {
   const n: number = graph.n;
   const nodeCommunity = new Int32Array(n);
@@ -94,44 +197,18 @@ export function makePartition(graph: GraphAdapter): Partition {
     communityTotalStrength.fill(0);
     communityTotalOutStrength.fill(0);
     communityTotalInStrength.fill(0);
-    for (let i = 0; i < n; i++) {
-      const c: number = iget(nodeCommunity, i);
-      communityTotalSize[c] = fget(communityTotalSize, c) + fget(graph.size, i);
-      communityNodeCount[c] = iget(communityNodeCount, c) + 1;
-      if (graph.directed) {
-        communityTotalOutStrength[c] =
-          fget(communityTotalOutStrength, c) + fget(graph.strengthOut, i);
-        communityTotalInStrength[c] = fget(communityTotalInStrength, c) + fget(graph.strengthIn, i);
-      } else {
-        communityTotalStrength[c] = fget(communityTotalStrength, c) + fget(graph.strengthOut, i);
-      }
-      if (fget(graph.selfLoop, i) !== 0)
-        communityInternalEdgeWeight[c] =
-          fget(communityInternalEdgeWeight, c) + fget(graph.selfLoop, i);
-    }
-    if (graph.directed) {
-      for (let i = 0; i < n; i++) {
-        const ci: number = iget(nodeCommunity, i);
-        const neighbors = graph.outEdges[i]!;
-        for (let k = 0; k < neighbors.length; k++) {
-          const { to: j, w } = neighbors[k]!;
-          if (i === j) continue; // self-loop already counted via graph.selfLoop[i]
-          if (ci === iget(nodeCommunity, j))
-            communityInternalEdgeWeight[ci] = fget(communityInternalEdgeWeight, ci) + w;
-        }
-      }
-    } else {
-      for (let i = 0; i < n; i++) {
-        const ci: number = iget(nodeCommunity, i);
-        const neighbors = graph.outEdges[i]!;
-        for (let k = 0; k < neighbors.length; k++) {
-          const { to: j, w } = neighbors[k]!;
-          if (j <= i) continue;
-          if (ci === iget(nodeCommunity, j))
-            communityInternalEdgeWeight[ci] = fget(communityInternalEdgeWeight, ci) + w;
-        }
-      }
-    }
+    accumulateNodeAggregates(
+      graph,
+      nodeCommunity,
+      n,
+      communityTotalSize,
+      communityNodeCount,
+      communityInternalEdgeWeight,
+      communityTotalStrength,
+      communityTotalOutStrength,
+      communityTotalInStrength,
+    );
+    accumulateInternalEdgeWeights(graph, nodeCommunity, n, communityInternalEdgeWeight);
   }
 
   function resetScratch(): void {
@@ -323,36 +400,15 @@ export function makePartition(graph: GraphAdapter): Partition {
   function compactCommunityIds(opts: CompactOptions = {}): void {
     const ids: number[] = [];
     for (let c = 0; c < communityCount; c++) if (iget(communityNodeCount, c) > 0) ids.push(c);
-    if (opts.keepOldOrder) {
-      ids.sort((a, b) => a - b);
-    } else if (opts.preserveMap instanceof Map) {
-      const preserveMap = opts.preserveMap;
-      ids.sort((a, b) => {
-        const pa = preserveMap.get(a);
-        const pb = preserveMap.get(b);
-        if (pa != null && pb != null && pa !== pb) return pa - pb;
-        if (pa != null && pb == null) return -1;
-        if (pb != null && pa == null) return 1;
-        return (
-          fget(communityTotalSize, b) - fget(communityTotalSize, a) ||
-          iget(communityNodeCount, b) - iget(communityNodeCount, a) ||
-          a - b
-        );
-      });
-    } else {
-      ids.sort(
-        (a, b) =>
-          fget(communityTotalSize, b) - fget(communityTotalSize, a) ||
-          iget(communityNodeCount, b) - iget(communityNodeCount, a) ||
-          a - b,
-      );
-    }
+    buildSortedCommunityIds(ids, opts, communityTotalSize, communityNodeCount);
+
     const newId = new Int32Array(communityCount).fill(-1);
     ids.forEach((c, i) => {
       newId[c] = i;
     });
     for (let i = 0; i < nodeCommunity.length; i++)
       nodeCommunity[i] = iget(newId, iget(nodeCommunity, i));
+
     const remappedCount: number = ids.length;
     const newTotalSize = new Float64Array(remappedCount);
     const newNodeCount = new Int32Array(remappedCount);
@@ -360,42 +416,19 @@ export function makePartition(graph: GraphAdapter): Partition {
     const newTotalStrength = new Float64Array(remappedCount);
     const newTotalOutStrength = new Float64Array(remappedCount);
     const newTotalInStrength = new Float64Array(remappedCount);
-    for (let i = 0; i < n; i++) {
-      const c: number = iget(nodeCommunity, i);
-      newTotalSize[c] = fget(newTotalSize, c) + fget(graph.size, i);
-      newNodeCount[c] = iget(newNodeCount, c) + 1;
-      if (graph.directed) {
-        newTotalOutStrength[c] = fget(newTotalOutStrength, c) + fget(graph.strengthOut, i);
-        newTotalInStrength[c] = fget(newTotalInStrength, c) + fget(graph.strengthIn, i);
-      } else {
-        newTotalStrength[c] = fget(newTotalStrength, c) + fget(graph.strengthOut, i);
-      }
-      if (fget(graph.selfLoop, i) !== 0)
-        newInternalEdgeWeight[c] = fget(newInternalEdgeWeight, c) + fget(graph.selfLoop, i);
-    }
-    if (graph.directed) {
-      for (let i = 0; i < n; i++) {
-        const ci: number = iget(nodeCommunity, i);
-        const list = graph.outEdges[i]!;
-        for (let k = 0; k < list.length; k++) {
-          const { to: j, w } = list[k]!;
-          if (i === j) continue; // self-loop already counted via graph.selfLoop[i]
-          if (ci === iget(nodeCommunity, j))
-            newInternalEdgeWeight[ci] = fget(newInternalEdgeWeight, ci) + w;
-        }
-      }
-    } else {
-      for (let i = 0; i < n; i++) {
-        const ci: number = iget(nodeCommunity, i);
-        const list = graph.outEdges[i]!;
-        for (let k = 0; k < list.length; k++) {
-          const { to: j, w } = list[k]!;
-          if (j <= i) continue;
-          if (ci === iget(nodeCommunity, j))
-            newInternalEdgeWeight[ci] = fget(newInternalEdgeWeight, ci) + w;
-        }
-      }
-    }
+    accumulateNodeAggregates(
+      graph,
+      nodeCommunity,
+      n,
+      newTotalSize,
+      newNodeCount,
+      newInternalEdgeWeight,
+      newTotalStrength,
+      newTotalOutStrength,
+      newTotalInStrength,
+    );
+    accumulateInternalEdgeWeights(graph, nodeCommunity, n, newInternalEdgeWeight);
+
     communityCount = remappedCount;
     communityTotalSize = newTotalSize;
     communityNodeCount = newNodeCount;

package/src/graph/model.ts

@@ -103,15 +103,27 @@ export class CodeGraph {
   }
 
   *edges(): Generator<[string, string, EdgeAttrs]> {
-    const seen = this._directed ? null : new Set<string>();
+    if (this._directed) {
+      yield* this._directedEdges();
+    } else {
+      yield* this._undirectedEdges();
+    }
+  }
+
+  private *_directedEdges(): Generator<[string, string, EdgeAttrs]> {
+    for (const [src, targets] of this._successors) {
+      for (const [tgt, attrs] of targets) yield [src, tgt, attrs];
+    }
+  }
+
+  private *_undirectedEdges(): Generator<[string, string, EdgeAttrs]> {
+    // \0 is safe as separator — node IDs are file paths/symbols, never contain null bytes
+    const seen = new Set<string>();
     for (const [src, targets] of this._successors) {
       for (const [tgt, attrs] of targets) {
-        if (!this._directed) {
-          // \0 is safe as separator — node IDs are file paths/symbols, never contain null bytes
-          const key = src < tgt ? `${src}\0${tgt}` : `${tgt}\0${src}`;
-          if (seen!.has(key)) continue;
-          seen!.add(key);
-        }
+        const key = src < tgt ? `${src}\0${tgt}` : `${tgt}\0${src}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
         yield [src, tgt, attrs];
       }
     }

package/src/infrastructure/config.ts

@@ -323,79 +323,70 @@ function resolveWorkspaceEntry(pkgDir: string): string | null {
  *   2. package.json — `workspaces` field (npm/yarn)
  *   3. lerna.json — `packages` array
  */
-export function detectWorkspaces(rootDir: string): Map<string, WorkspaceEntry> {
-  const workspaces = new Map<string, WorkspaceEntry>();
-  const patterns: string[] = [];
-
-  // 1. pnpm-workspace.yaml
+/** Read pnpm-workspace.yaml and return workspace glob patterns. */
+function readPnpmWorkspacePatterns(rootDir: string): string[] {
   const pnpmPath = path.join(rootDir, 'pnpm-workspace.yaml');
-  if (fs.existsSync(pnpmPath)) {
-    try {
-      const raw = fs.readFileSync(pnpmPath, 'utf-8');
-      // Simple YAML parse for `packages:` array — no dependency needed
-      const packagesMatch = raw.match(/^packages:\s*\n((?:\s+-\s+.+\n?)*)/m);
-      if (packagesMatch) {
-        const lines = packagesMatch[1]!.match(/^\s+-\s+['"]?([^'"#\n]+)['"]?\s*$/gm);
-        if (lines) {
-          for (const line of lines) {
-            const m = line.match(/^\s+-\s+['"]?([^'"#\n]+?)['"]?\s*$/);
-            if (m) patterns.push(m[1]!.trim());
-          }
-        }
-      }
-    } catch (e) {
-      debug(`detectWorkspaces: failed to parse pnpm-workspace.yaml: ${toErrorMessage(e)}`);
+  if (!fs.existsSync(pnpmPath)) return [];
+  try {
+    const raw = fs.readFileSync(pnpmPath, 'utf-8');
+    const packagesMatch = raw.match(/^packages:\s*\n((?:\s+-\s+.+\n?)*)/m);
+    if (!packagesMatch) return [];
+    const lines = packagesMatch[1]!.match(/^\s+-\s+['"]?([^'"#\n]+)['"]?\s*$/gm);
+    if (!lines) return [];
+    const patterns: string[] = [];
+    for (const line of lines) {
+      const m = line.match(/^\s+-\s+['"]?([^'"#\n]+?)['"]?\s*$/);
+      if (m) patterns.push(m[1]!.trim());
     }
+    return patterns;
+  } catch (e) {
+    debug(`detectWorkspaces: failed to parse pnpm-workspace.yaml: ${toErrorMessage(e)}`);
+    return [];
   }
+}
 
-  // 2. package.json workspaces (npm/yarn)
-  if (patterns.length === 0) {
-    const rootPkgPath = path.join(rootDir, 'package.json');
-    if (fs.existsSync(rootPkgPath)) {
-      try {
-        const raw = fs.readFileSync(rootPkgPath, 'utf-8');
-        const pkg = JSON.parse(raw);
-        const ws = pkg.workspaces;
-        if (Array.isArray(ws)) {
-          patterns.push(...ws);
-        } else if (ws && Array.isArray(ws.packages)) {
-          // Yarn classic format: { packages: [...], nohoist: [...] }
-          patterns.push(...ws.packages);
-        }
-      } catch (e) {
-        debug(`detectWorkspaces: failed to parse package.json workspaces: ${toErrorMessage(e)}`);
-      }
-    }
+/** Read package.json workspaces field (npm/yarn) and return glob patterns. */
+function readNpmWorkspacePatterns(rootDir: string): string[] {
+  const rootPkgPath = path.join(rootDir, 'package.json');
+  if (!fs.existsSync(rootPkgPath)) return [];
+  try {
+    const raw = fs.readFileSync(rootPkgPath, 'utf-8');
+    const pkg = JSON.parse(raw);
+    const ws = pkg.workspaces;
+    if (Array.isArray(ws)) return ws;
+    if (ws && Array.isArray(ws.packages)) return ws.packages;
+    return [];
+  } catch (e) {
+    debug(`detectWorkspaces: failed to parse package.json workspaces: ${toErrorMessage(e)}`);
+    return [];
   }
+}
 
-  // 3. lerna.json
-  if (patterns.length === 0) {
-    const lernaPath = path.join(rootDir, 'lerna.json');
-    if (fs.existsSync(lernaPath)) {
-      try {
-        const raw = fs.readFileSync(lernaPath, 'utf-8');
-        const lerna = JSON.parse(raw);
-        if (Array.isArray(lerna.packages)) {
-          patterns.push(...lerna.packages);
-        }
-      } catch (e) {
-        debug(`detectWorkspaces: failed to parse lerna.json: ${toErrorMessage(e)}`);
-      }
-    }
+/** Read lerna.json packages field and return glob patterns. */
+function readLernaPatterns(rootDir: string): string[] {
+  const lernaPath = path.join(rootDir, 'lerna.json');
+  if (!fs.existsSync(lernaPath)) return [];
+  try {
+    const raw = fs.readFileSync(lernaPath, 'utf-8');
+    const lerna = JSON.parse(raw);
+    if (Array.isArray(lerna.packages)) return lerna.packages;
+    return [];
+  } catch (e) {
+    debug(`detectWorkspaces: failed to parse lerna.json: ${toErrorMessage(e)}`);
+    return [];
   }
+}
 
-  if (patterns.length === 0) return workspaces;
-
-  // Expand glob patterns and collect packages
+/** Expand workspace patterns into concrete package entries. */
+function expandWorkspacePatterns(patterns: string[], rootDir: string): Map<string, WorkspaceEntry> {
+  const workspaces = new Map<string, WorkspaceEntry>();
   for (const pattern of patterns) {
-    // Check if pattern is a direct path (no glob) or a glob
     if (pattern.includes('*')) {
       for (const dir of expandWorkspaceGlob(pattern, rootDir)) {
         const name = readPackageName(dir);
         if (name) workspaces.set(name, { dir, entry: resolveWorkspaceEntry(dir) });
       }
     } else {
-      // Direct path like "packages/core"
       const dir = path.resolve(rootDir, pattern);
       if (fs.existsSync(path.join(dir, 'package.json'))) {
         const name = readPackageName(dir);
@@ -403,6 +394,17 @@ export function detectWorkspaces(rootDir: string): Map<string, WorkspaceEntry> {
       }
     }
   }
+  return workspaces;
+}
+
+export function detectWorkspaces(rootDir: string): Map<string, WorkspaceEntry> {
+  // Try each package manager in priority order — first match wins
+  let patterns = readPnpmWorkspacePatterns(rootDir);
+  if (patterns.length === 0) patterns = readNpmWorkspacePatterns(rootDir);
+  if (patterns.length === 0) patterns = readLernaPatterns(rootDir);
+  if (patterns.length === 0) return new Map();
+
+  const workspaces = expandWorkspacePatterns(patterns, rootDir);
 
   if (workspaces.size > 0) {
     debug(`Detected ${workspaces.size} workspace packages: ${[...workspaces.keys()].join(', ')}`);

package/src/infrastructure/registry.ts

@@ -56,6 +56,22 @@ export function saveRegistry(registry: Registry, registryPath: string = REGISTRY
  * pointing to a different path, auto-suffixes (`api` → `api-2`, `api-3`, …).
  * Re-registering the same path updates in place. Explicit names always overwrite.
  */
+
+/** Find a unique suffixed name when the base name collides with a different path. */
+function findAvailableName(
+  baseName: string,
+  absRoot: string,
+  repos: Record<string, RegistryEntry>,
+): string {
+  let suffix = 2;
+  while (repos[`${baseName}-${suffix}`]) {
+    const entry = repos[`${baseName}-${suffix}`]!;
+    if (path.resolve(entry.path) === absRoot) return `${baseName}-${suffix}`;
+    suffix++;
+  }
+  return `${baseName}-${suffix}`;
+}
+
 export function registerRepo(
   rootDir: string,
   name?: string,
@@ -71,20 +87,7 @@ export function registerRepo(
   if (!name) {
     const existing = registry.repos[baseName];
     if (existing && path.resolve(existing.path) !== absRoot) {
-      // Basename collision with a different path — find next available suffix
-      let suffix = 2;
-      while (registry.repos[`${baseName}-${suffix}`]) {
-        const entry = registry.repos[`${baseName}-${suffix}`]!;
-        if (path.resolve(entry.path) === absRoot) {
-          // Already registered under this suffixed name — update in place
-          repoName = `${baseName}-${suffix}`;
-          break;
-        }
-        suffix++;
-      }
-      if (repoName === baseName) {
-        repoName = `${baseName}-${suffix}`;
-      }
+      repoName = findAvailableName(baseName, absRoot, registry.repos);
     }
   }
 

package/src/mcp/server.ts

@@ -109,6 +109,51 @@ function validateMultiRepoAccess(multiRepo: boolean, name: string, args: { repo?
   }
 }
 
+/**
+ * Register process-level shutdown and error handlers once per process.
+ * Ensures graceful cleanup when the MCP client disconnects or the transport
+ * encounters broken-pipe errors. Uses a globalThis flag to survive
+ * vi.resetModules() in tests.
+ */
+function registerShutdownHandlers(): void {
+  const g = globalThis as Record<string, unknown>;
+  if (g.__codegraph_shutdown_installed) return;
+  g.__codegraph_shutdown_installed = true;
+
+  const shutdown = async () => {
+    try {
+      await _activeServer?.close();
+    } catch (_shutdownErr: unknown) {
+      // Ignore close errors during shutdown — the transport may already be gone.
+    }
+    process.exit(0);
+  };
+  const silentExit = (err: Error & { code?: string }) => {
+    // Only suppress broken-pipe errors from closed stdio transport;
+    // let real bugs surface with a non-zero exit code.
+    if (err.code === 'EPIPE' || err.code === 'ERR_STREAM_DESTROYED') {
+      process.exit(0);
+    }
+    process.stderr.write(`Uncaught exception: ${err.stack ?? err.message}\n`);
+    process.exit(1);
+  };
+  const silentReject = (reason: unknown) => {
+    const err = reason instanceof Error ? reason : new Error(String(reason));
+    const code = (err as Error & { code?: string }).code;
+    if (code === 'EPIPE' || code === 'ERR_STREAM_DESTROYED') {
+      process.exit(0);
+    }
+    process.stderr.write(`Unhandled rejection: ${err.stack ?? err.message}\n`);
+    process.exit(1);
+  };
+
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+  process.on('SIGHUP', shutdown);
+  process.on('uncaughtException', silentExit);
+  process.on('unhandledRejection', silentReject);
+}
+
 export async function startMCPServer(
   customDbPath?: string,
   options: MCPServerOptionsInternal = {},
@@ -180,43 +225,7 @@ export async function startMCPServer(
   // the latest instance (matters when tests call startMCPServer repeatedly).
   _activeServer = server;
 
-  // Register handlers once per process to avoid listener accumulation.
-  // Use a process-level flag so it survives vi.resetModules() in tests.
-  const g = globalThis as Record<string, unknown>;
-  if (!g.__codegraph_shutdown_installed) {
-    g.__codegraph_shutdown_installed = true;
-
-    const shutdown = async () => {
-      try {
-        await _activeServer?.close();
-      } catch {}
-      process.exit(0);
-    };
-    const silentExit = (err: Error & { code?: string }) => {
-      // Only suppress broken-pipe errors from closed stdio transport;
-      // let real bugs surface with a non-zero exit code.
-      if (err.code === 'EPIPE' || err.code === 'ERR_STREAM_DESTROYED') {
-        process.exit(0);
-      }
-      process.stderr.write(`Uncaught exception: ${err.stack ?? err.message}\n`);
-      process.exit(1);
-    };
-    const silentReject = (reason: unknown) => {
-      const err = reason instanceof Error ? reason : new Error(String(reason));
-      const code = (err as Error & { code?: string }).code;
-      if (code === 'EPIPE' || code === 'ERR_STREAM_DESTROYED') {
-        process.exit(0);
-      }
-      process.stderr.write(`Unhandled rejection: ${err.stack ?? err.message}\n`);
-      process.exit(1);
-    };
-
-    process.on('SIGINT', shutdown);
-    process.on('SIGTERM', shutdown);
-    process.on('SIGHUP', shutdown);
-    process.on('uncaughtException', silentExit);
-    process.on('unhandledRejection', silentReject);
-  }
+  registerShutdownHandlers();
 
   try {
     await server.connect(transport);