@calltelemetry/cucm-mcp 0.1.7 → 0.2.3

package/dist/packetCapture.js

@@ -2,398 +2,340 @@ import crypto from "node:crypto";
 import { Client } from "ssh2";
 import { defaultStateStore } from "./state.js";
 function extractCapFilePath(text) {
-    if (!text)
-        return undefined;
-    // CUCM typically writes captures to /var/log/active/platform/cli/<name>.cap
-    // Sometimes CLI output includes the final on-disk location.
-    const re = /\/var\/log\/active\/platform\/cli\/[A-Za-z0-9._-]+\.cap/g;
-    const matches = text.match(re);
-    if (!matches || matches.length === 0)
-        return undefined;
-    return matches[matches.length - 1];
+  if (!text) return void 0;
+  const re = /\/var\/log\/active\/platform\/cli\/[A-Za-z0-9._-]+\.cap/g;
+  const matches = text.match(re);
+  if (!matches || matches.length === 0) return void 0;
+  return matches[matches.length - 1];
 }
 function looksLikeCucmPrompt(text) {
-    const t = String(text || "");
-    // CUCM CLI commonly ends commands by printing a prompt like:
-    //   admin:
-    // Some environments might show other usernames.
-    // We only look at the tail to avoid false positives.
-    const tail = t.slice(-80);
-    return /(?:^|\n)[A-Za-z0-9_-]+:\s*$/.test(tail);
+  const t = String(text || "");
+  const tail = t.slice(-80);
+  return /(?:^|\n)[A-Za-z0-9_-]+:\s*$/.test(tail);
 }
-export function resolveSshAuth(auth) {
-    const username = auth?.username || process.env.CUCM_SSH_USERNAME;
-    const password = auth?.password || process.env.CUCM_SSH_PASSWORD;
-    if (!username || !password) {
-        throw new Error("Missing SSH credentials (provide auth or set CUCM_SSH_USERNAME/CUCM_SSH_PASSWORD)");
-    }
-    return { username, password };
+function resolveSshAuth(auth) {
+  const username = auth?.username || process.env.CUCM_SSH_USERNAME;
+  const password = auth?.password || process.env.CUCM_SSH_PASSWORD;
+  if (!username || !password) {
+    throw new Error("Missing SSH credentials (provide auth or set CUCM_SSH_USERNAME/CUCM_SSH_PASSWORD)");
+  }
+  return { username, password };
 }
-export function sanitizeFileBase(s) {
-    // CUCM note: fname should not contain '.'
-    // Keep it conservative.
-    const cleaned = String(s || "")
-        .trim()
-        .replaceAll(".", "_")
-        .replace(/[^A-Za-z0-9_-]+/g, "_")
-        .replace(/^_+/, "")
-        .replace(/_+$/, "");
-    if (!cleaned)
-        throw new Error("fileBase is required (after sanitization)");
-    return cleaned;
+function sanitizeFileBase(s) {
+  const cleaned = String(s || "").trim().replaceAll(".", "_").replace(/[^A-Za-z0-9_-]+/g, "_").replace(/^_+/, "").replace(/_+$/, "");
+  if (!cleaned) throw new Error("fileBase is required (after sanitization)");
+  return cleaned;
 }
-export function buildCaptureCommand(opts) {
-    const iface = String(opts.iface || "eth0").trim() || "eth0";
-    const fileBase = sanitizeFileBase(opts.fileBase);
-    const count = Number.isFinite(opts.count) ? Math.trunc(opts.count) : 100000;
-    if (count <= 0)
-        throw new Error("count must be > 0");
-    const size = String(opts.size || "all").trim() || "all";
-    const args = [
-        "utils",
-        "network",
-        "capture",
-        iface,
-        "file",
-        fileBase,
-        "count",
-        String(count),
-        "size",
-        size,
-    ];
-    if (opts.portFilter != null) {
-        const p = Math.trunc(opts.portFilter);
-        if (p < 1 || p > 65535)
-            throw new Error("portFilter must be 1..65535");
-        args.push("port", String(p));
-    }
-    if (opts.hostFilterIp) {
-        const ip = String(opts.hostFilterIp).trim();
-        if (!ip)
-            throw new Error("hostFilterIp must be non-empty");
-        args.push("host", "ip", ip);
-    }
-    return args.join(" ");
+function buildCaptureCommand(opts) {
+  const iface = String(opts.iface || "eth0").trim() || "eth0";
+  const fileBase = sanitizeFileBase(opts.fileBase);
+  const count = Number.isFinite(opts.count) ? Math.trunc(opts.count) : 1e5;
+  if (count <= 0) throw new Error("count must be > 0");
+  const size = String(opts.size || "all").trim() || "all";
+  const args = [
+    "utils",
+    "network",
+    "capture",
+    iface,
+    "file",
+    fileBase,
+    "count",
+    String(count),
+    "size",
+    size
+  ];
+  if (opts.portFilter != null) {
+    const p = Math.trunc(opts.portFilter);
+    if (p < 1 || p > 65535) throw new Error("portFilter must be 1..65535");
+    args.push("port", String(p));
+  }
+  if (opts.hostFilterIp) {
+    const ip = String(opts.hostFilterIp).trim();
+    if (!ip) throw new Error("hostFilterIp must be non-empty");
+    args.push("host", "ip", ip);
+  }
+  return args.join(" ");
 }
-export function remoteCapturePath(fileBase) {
-    const fb = sanitizeFileBase(fileBase);
-    return `/var/log/active/platform/cli/${fb}.cap`;
+function remoteCapturePath(fileBase) {
+  const fb = sanitizeFileBase(fileBase);
+  return `/var/log/active/platform/cli/${fb}.cap`;
 }
-export function remoteCaptureCandidates(fileBase, maxParts = 10) {
-    const fb = sanitizeFileBase(fileBase);
-    const base = `/var/log/active/platform/cli/${fb}.cap`;
-    const out = [base];
-    // Some CUCM/VOS versions roll packet capture files as .cap01, .cap02, ...
-    for (let i = 1; i <= maxParts; i++) {
-        const suffix = String(i).padStart(2, "0");
-        out.push(`/var/log/active/platform/cli/${fb}.cap${suffix}`);
-    }
-    return out;
+function remoteCaptureCandidates(fileBase, maxParts = 10) {
+  const fb = sanitizeFileBase(fileBase);
+  const base = `/var/log/active/platform/cli/${fb}.cap`;
+  const out = [base];
+  for (let i = 1; i <= maxParts; i++) {
+    const suffix = String(i).padStart(2, "0");
+    out.push(`/var/log/active/platform/cli/${fb}.cap${suffix}`);
+  }
+  return out;
 }
 function waitFor(channel, session, predicate, timeoutMs, timeoutMessage) {
-    return new Promise((resolve, reject) => {
-        if (predicate())
-            return resolve();
-        const onData = () => {
-            if (predicate())
-                cleanup(true);
-        };
-        let timer;
-        const cleanup = (ok) => {
-            channel.off("data", onData);
-            channel.stderr.off("data", onData);
-            if (timer)
-                clearTimeout(timer);
-            if (ok)
-                resolve();
-            else {
-                const tail = (session.lastStdout || session.lastStderr || "").slice(-400);
-                reject(new Error(`${timeoutMessage}. lastOutput=${JSON.stringify(tail)}`));
-            }
-        };
-        channel.on("data", onData);
-        channel.stderr.on("data", onData);
-        timer = setTimeout(() => cleanup(false), Math.max(1000, timeoutMs));
-        timer.unref?.();
-    });
+  return new Promise((resolve, reject) => {
+    if (predicate()) return resolve();
+    const onData = () => {
+      if (predicate()) cleanup(true);
+    };
+    let timer;
+    const cleanup = (ok) => {
+      channel.off("data", onData);
+      channel.stderr.off("data", onData);
+      if (timer) clearTimeout(timer);
+      if (ok) resolve();
+      else {
+        const tail = (session.lastStdout || session.lastStderr || "").slice(-400);
+        reject(new Error(`${timeoutMessage}. lastOutput=${JSON.stringify(tail)}`));
+      }
+    };
+    channel.on("data", onData);
+    channel.stderr.on("data", onData);
+    timer = setTimeout(() => cleanup(false), Math.max(1e3, timeoutMs));
+    timer.unref?.();
+  });
 }
-export class PacketCaptureManager {
-    active = new Map();
-    state;
-    constructor(opts) {
-        this.state = opts?.state || defaultStateStore();
-    }
-    list() {
-        return [...this.active.values()].map((a) => a.session);
-    }
-    async start(opts) {
-        const iface = String(opts.iface || "eth0").trim() || "eth0";
-        const fileBase = sanitizeFileBase(opts.fileBase || `cap_${Date.now()}`);
-        const count = opts.count ?? 100000;
-        const size = opts.size ?? "all";
-        const cmd = buildCaptureCommand({ iface, fileBase, count, size, hostFilterIp: opts.hostFilterIp, portFilter: opts.portFilter });
-        const id = crypto.randomUUID();
-        const sshPort = opts.sshPort ?? (process.env.CUCM_SSH_PORT ? Number.parseInt(process.env.CUCM_SSH_PORT, 10) : 22);
-        const auth = resolveSshAuth(opts.auth);
-        const client = new Client();
-        const startedAt = new Date().toISOString();
-        const session = {
-            id,
+class PacketCaptureManager {
+  active = /* @__PURE__ */ new Map();
+  state;
+  constructor(opts) {
+    this.state = opts?.state || defaultStateStore();
+  }
+  list() {
+    return [...this.active.values()].map((a) => a.session);
+  }
+  async start(opts) {
+    const iface = String(opts.iface || "eth0").trim() || "eth0";
+    const fileBase = sanitizeFileBase(opts.fileBase || `cap_${Date.now()}`);
+    const count = opts.count ?? 1e5;
+    const size = opts.size ?? "all";
+    const cmd = buildCaptureCommand({ iface, fileBase, count, size, hostFilterIp: opts.hostFilterIp, portFilter: opts.portFilter });
+    const id = crypto.randomUUID();
+    const sshPort = opts.sshPort ?? (process.env.CUCM_SSH_PORT ? Number.parseInt(process.env.CUCM_SSH_PORT, 10) : 22);
+    const auth = resolveSshAuth(opts.auth);
+    const client = new Client();
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const session = {
+      id,
+      host: opts.host,
+      startedAt,
+      iface,
+      fileBase,
+      remoteFilePath: remoteCapturePath(fileBase),
+      remoteFileCandidates: remoteCaptureCandidates(fileBase)
+    };
+    this.state.upsert({
+      ...session,
+      stoppedAt: session.stoppedAt
+    });
+    const startTimeoutMs = Math.max(2e3, Math.trunc(opts.startTimeoutMs ?? 3e4));
+    let connectTimer;
+    const connectTimeout = new Promise((_, reject) => {
+      connectTimer = setTimeout(() => reject(new Error(`SSH connect timed out after ${startTimeoutMs}ms`)), startTimeoutMs);
+      connectTimer.unref?.();
+    });
+    try {
+      await Promise.race([
+        new Promise((resolve, reject) => {
+          client.on("ready", () => resolve()).on("error", (e) => reject(e)).connect({
             host: opts.host,
-            startedAt,
-            iface,
-            fileBase,
-            remoteFilePath: remoteCapturePath(fileBase),
-            remoteFileCandidates: remoteCaptureCandidates(fileBase),
-        };
-        // Persist early so we can recover/download even if the MCP process restarts.
-        this.state.upsert({
-            ...session,
-            stoppedAt: session.stoppedAt,
-        });
-        await new Promise((resolve, reject) => {
-            client
-                .on("ready", () => resolve())
-                .on("error", (e) => reject(e))
-                .connect({
-                host: opts.host,
-                port: sshPort,
-                username: auth.username,
-                password: auth.password,
-                readyTimeout: 15000,
-            });
-        });
-        // CUCM SSH presents an interactive CLI shell. `exec()` is not reliably supported,
-        // so we open a shell and type commands at the prompt.
-        const channel = await new Promise((resolve, reject) => {
-            client.shell({ term: "vt100", cols: 120, rows: 40 }, (err, ch) => {
-                if (err)
-                    return reject(err);
-                resolve(ch);
-            });
-        });
-        channel.on("data", (buf) => {
-            session.lastStdout = buf.toString("utf8").slice(-2000);
-            this.state.upsert({ ...session, stoppedAt: session.stoppedAt });
-        });
-        channel.stderr.on("data", (buf) => {
-            session.lastStderr = buf.toString("utf8").slice(-2000);
-            this.state.upsert({ ...session, stoppedAt: session.stoppedAt });
-        });
-        channel.on("close", (code) => {
-            session.exitCode = code;
-            session.stoppedAt = session.stoppedAt || new Date().toISOString();
-            // If the capture stopped unexpectedly, drop it from the active map.
-            this.active.delete(id);
-            this.state.upsert({ ...session, stoppedAt: session.stoppedAt });
-            try {
-                client.end();
-                client.destroy();
-            }
-            catch {
-                // ignore
-            }
-        });
-        // Wait for prompt before running capture command.
-        // Some CUCM shells don't print a prompt until you send a newline.
-        const promptTimeoutMs = Math.max(2000, Math.trunc(opts.startTimeoutMs ?? 30_000));
-        try {
-            try {
-                channel.write("\n");
-            }
-            catch {
-                // ignore
-            }
-            // Nudge a couple times if no prompt yet.
-            void (async () => {
-                const delays = [400, 1200, 2500];
-                for (const d of delays) {
-                    await new Promise((r) => setTimeout(r, d));
-                    if (looksLikeCucmPrompt(session.lastStdout) || looksLikeCucmPrompt(session.lastStderr))
-                        return;
-                    try {
-                        channel.write("\n");
-                    }
-                    catch {
-                        // ignore
-                    }
-                }
-            })();
-            await waitFor(channel, session, () => looksLikeCucmPrompt(session.lastStdout) || looksLikeCucmPrompt(session.lastStderr), promptTimeoutMs, "Timeout waiting for CUCM CLI prompt");
-            channel.write(`${cmd}\n`);
-        }
-        catch (e) {
-            try {
-                channel.end();
-                channel.close();
-            }
-            catch {
-                // ignore
-            }
-            try {
-                client.end();
-                client.destroy();
-            }
-            catch {
-                // ignore
-            }
-            throw e;
-        }
-        this.active.set(id, { session, client, channel });
-        // Optional guard: stop after a duration even if packet count isn't reached.
-        if (opts.maxDurationMs != null) {
-            const dur = Math.max(250, Math.trunc(opts.maxDurationMs));
-            const t = setTimeout(() => {
-                void this.stop(id).catch(() => {
-                    // ignore
-                });
-            }, dur);
-            t.unref?.();
+            port: sshPort,
+            username: auth.username,
+            password: auth.password,
+            readyTimeout: 15e3
+          });
+        }),
+        connectTimeout
+      ]);
+    } finally {
+      if (connectTimer) clearTimeout(connectTimer);
+    }
+    const channel = await new Promise((resolve, reject) => {
+      client.shell({ term: "vt100", cols: 120, rows: 40 }, (err, ch) => {
+        if (err) return reject(err);
+        resolve(ch);
+      });
+    });
+    channel.on("data", (buf) => {
+      session.lastStdout = buf.toString("utf8").slice(-2e3);
+      this.state.upsert({ ...session, stoppedAt: session.stoppedAt });
+    });
+    channel.stderr.on("data", (buf) => {
+      session.lastStderr = buf.toString("utf8").slice(-2e3);
+      this.state.upsert({ ...session, stoppedAt: session.stoppedAt });
+    });
+    channel.on("close", (code) => {
+      session.exitCode = code;
+      session.stoppedAt = session.stoppedAt || (/* @__PURE__ */ new Date()).toISOString();
+      this.active.delete(id);
+      this.state.upsert({ ...session, stoppedAt: session.stoppedAt });
+      try {
+        client.end();
+        client.destroy();
+      } catch {
+      }
+    });
+    const promptTimeoutMs = startTimeoutMs;
+    try {
+      try {
+        channel.write("\n");
+      } catch {
+      }
+      void (async () => {
+        const delays = [400, 1200, 2500];
+        for (const d of delays) {
+          await new Promise((r) => setTimeout(r, d));
+          if (looksLikeCucmPrompt(session.lastStdout) || looksLikeCucmPrompt(session.lastStderr)) return;
+          try {
+            channel.write("\n");
+          } catch {
+          }
         }
-        return session;
+      })();
+      await waitFor(
+        channel,
+        session,
+        () => looksLikeCucmPrompt(session.lastStdout) || looksLikeCucmPrompt(session.lastStderr),
+        promptTimeoutMs,
+        "Timeout waiting for CUCM CLI prompt"
+      );
+      channel.write(`${cmd}
+`);
+    } catch (e) {
+      try {
+        channel.end();
+        channel.close();
+      } catch {
+      }
+      try {
+        client.end();
+        client.destroy();
+      } catch {
+      }
+      throw e;
     }
-    async stop(captureId, timeoutMs = 90_000) {
-        const a = this.active.get(captureId);
-        if (!a)
-            throw new Error(`Unknown captureId: ${captureId}`);
-        const { channel, client, session } = a;
-        const done = new Promise((resolve) => {
-            if (looksLikeCucmPrompt(session.lastStdout) || looksLikeCucmPrompt(session.lastStderr)) {
-                return resolve();
-            }
-            // CUCM CLI can keep the SSH channel open after the command finishes
-            // (it returns to a prompt rather than exiting). Treat prompt as "stopped".
-            const onData = () => {
-                if (looksLikeCucmPrompt(session.lastStdout) || looksLikeCucmPrompt(session.lastStderr)) {
-                    cleanup();
-                    resolve();
-                }
-            };
-            const cleanup = () => {
-                channel.off("data", onData);
-                channel.stderr.off("data", onData);
-            };
-            const finish = () => {
-                cleanup();
-                resolve();
-            };
-            channel.once("exit", finish);
-            channel.once("close", finish);
-            channel.once("end", finish);
-            channel.on("data", onData);
-            channel.stderr.on("data", onData);
+    this.active.set(id, { session, client, channel });
+    if (opts.maxDurationMs != null) {
+      const dur = Math.max(250, Math.trunc(opts.maxDurationMs));
+      const t = setTimeout(() => {
+        void this.stop(id).catch(() => {
         });
-        const sendInterrupt = () => {
-            // Best-effort interrupt.
-            try {
-                if (typeof channel.signal === "function")
-                    channel.signal("INT");
-                // Always also write Ctrl-C for PTY sessions.
-                channel.write("\x03");
-            }
-            catch {
-                try {
-                    channel.write("\x03");
-                }
-                catch {
-                    // ignore
-                }
-            }
-        };
-        // CUCM can take a while to flush/close captures (especially big buffers).
-        // Also, some CLI flows require a second Ctrl-C or a newline to return to prompt.
-        const resolvedTimeoutMs = Math.max(5000, timeoutMs || 0);
-        const deadline = Date.now() + resolvedTimeoutMs;
-        sendInterrupt();
-        // Nudge again a couple times if it doesn't exit quickly.
-        void (async () => {
-            const delays = [750, 1500, 3000];
-            for (const d of delays) {
-                await new Promise((r) => setTimeout(r, d));
-                if (Date.now() >= deadline)
-                    return;
-                // If channel already closed, no-op.
-                sendInterrupt();
-                try {
-                    channel.write("\n");
-                }
-                catch {
-                    // ignore
-                }
-            }
-        })();
-        try {
-            let timer;
-            const timeout = new Promise((_, reject) => {
-                timer = setTimeout(() => reject(new Error("Timeout waiting for capture to stop")), resolvedTimeoutMs);
-                // Don't keep the process alive just because we're waiting.
-                timer.unref?.();
-            });
-            try {
-                await Promise.race([done, timeout]);
-            }
-            finally {
-                if (timer)
-                    clearTimeout(timer);
-            }
-        }
-        catch (e) {
-            // Don't hard-fail: if the CLI doesn't emit a prompt/exit, we still want to:
-            // - close SSH resources
-            // - let the caller try DIME downloads (.cap, .cap01, etc)
-            session.stopTimedOut = true;
-            session.stoppedAt = session.stoppedAt || new Date().toISOString();
-            this.state.upsert({ ...session, stoppedAt: session.stoppedAt });
-            try {
-                channel.close();
-            }
-            catch {
-                // ignore
-            }
-        }
-        session.stoppedAt = new Date().toISOString();
-        this.state.upsert({ ...session, stoppedAt: session.stoppedAt });
-        // If we're back at a CUCM prompt, try to close the session cleanly.
+      }, dur);
+      t.unref?.();
+    }
+    return session;
+  }
+  async stop(captureId, timeoutMs = 9e4) {
+    const a = this.active.get(captureId);
+    if (!a) throw new Error(`Unknown captureId: ${captureId}`);
+    const { channel, client, session } = a;
+    const done = new Promise((resolve) => {
+      if (looksLikeCucmPrompt(session.lastStdout) || looksLikeCucmPrompt(session.lastStderr)) {
+        return resolve();
+      }
+      const onData = () => {
         if (looksLikeCucmPrompt(session.lastStdout) || looksLikeCucmPrompt(session.lastStderr)) {
-            try {
-                channel.write("exit\n");
-            }
-            catch {
-                // ignore
-            }
-        }
-        // Ensure the channel is closed so the SSH client can terminate promptly.
-        try {
-            channel.end();
-        }
-        catch {
-            // ignore
+          cleanup();
+          resolve();
         }
+      };
+      const cleanup = () => {
+        channel.off("data", onData);
+        channel.stderr.off("data", onData);
+      };
+      const finish = () => {
+        cleanup();
+        resolve();
+      };
+      channel.once("exit", finish);
+      channel.once("close", finish);
+      channel.once("end", finish);
+      channel.on("data", onData);
+      channel.stderr.on("data", onData);
+    });
+    const sendInterrupt = () => {
+      try {
+        if (typeof channel.signal === "function") channel.signal("INT");
+        channel.write("");
+      } catch {
         try {
-            channel.close();
-        }
-        catch {
-            // ignore
-        }
-        // Attempt to learn the actual remote file path from CLI output.
-        // This helps when CUCM appends suffixes or reports a different on-disk location.
-        const inferred = extractCapFilePath(session.lastStdout) || extractCapFilePath(session.lastStderr);
-        if (inferred) {
-            session.remoteFilePath = inferred;
-            if (!session.remoteFileCandidates.includes(inferred)) {
-                session.remoteFileCandidates = [inferred, ...session.remoteFileCandidates];
-            }
+          channel.write("");
+        } catch {
         }
-        this.state.upsert({ ...session, stoppedAt: session.stoppedAt });
-        // stop() implies cleanup
-        this.active.delete(captureId);
+      }
+    };
+    const resolvedTimeoutMs = Math.max(5e3, timeoutMs || 0);
+    const deadline = Date.now() + resolvedTimeoutMs;
+    sendInterrupt();
+    void (async () => {
+      const delays = [750, 1500, 3e3];
+      for (const d of delays) {
+        await new Promise((r) => setTimeout(r, d));
+        if (Date.now() >= deadline) return;
+        sendInterrupt();
         try {
-            client.end();
-            client.destroy();
-        }
-        catch {
-            // ignore
+          channel.write("\n");
+        } catch {
         }
-        return session;
+      }
+    })();
+    try {
+      let timer;
+      const timeout = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error("Timeout waiting for capture to stop")), resolvedTimeoutMs);
+        timer.unref?.();
+      });
+      try {
+        await Promise.race([done, timeout]);
+      } finally {
+        if (timer) clearTimeout(timer);
+      }
+    } catch (e) {
+      session.stopTimedOut = true;
+      session.stoppedAt = session.stoppedAt || (/* @__PURE__ */ new Date()).toISOString();
+      this.state.upsert({ ...session, stoppedAt: session.stoppedAt });
+      try {
+        channel.close();
+      } catch {
+      }
+    }
+    session.stoppedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.state.upsert({ ...session, stoppedAt: session.stoppedAt });
+    if (looksLikeCucmPrompt(session.lastStdout) || looksLikeCucmPrompt(session.lastStderr)) {
+      try {
+        channel.write("exit\n");
+      } catch {
+      }
+    }
+    try {
+      channel.end();
+    } catch {
+    }
+    try {
+      channel.close();
+    } catch {
+    }
+    const inferred = extractCapFilePath(session.lastStdout) || extractCapFilePath(session.lastStderr);
+    if (inferred) {
+      session.remoteFilePath = inferred;
+      if (!session.remoteFileCandidates.includes(inferred)) {
+        session.remoteFileCandidates = [inferred, ...session.remoteFileCandidates];
+      }
+    }
+    this.state.upsert({ ...session, stoppedAt: session.stoppedAt });
+    this.active.delete(captureId);
+    try {
+      client.end();
+      client.destroy();
+    } catch {
     }
+    return session;
+  }
 }
+export {
+  PacketCaptureManager,
+  buildCaptureCommand,
+  remoteCaptureCandidates,
+  remoteCapturePath,
+  resolveSshAuth,
+  sanitizeFileBase
+};
+//# sourceMappingURL=packetCapture.js.map