@calltelemetry/cucm-mcp 0.1.3 → 0.1.5

package/README.md

@@ -84,3 +84,9 @@ Live tests are opt-in via env vars; see `test/live.test.js`.
 - `packet_capture_stop_and_download` - stop capture + download `.cap` via DIME
 - `packet_capture_state_list` - list captures from state file
 - `packet_capture_download_from_state` - download by captureId after restart
+
+## Packet Capture Notes
+
+- Use the platform/OS admin for SSH (`administrator` user on most lab systems)
+- To request a high packet count without specifying an exact number, pass `maxPackets: true` to `packet_capture_start`
+- If traffic is low, a small `count` can still run “forever” waiting for packets; use `packet_capture_stop` to cancel, or set `maxDurationMs` to auto-stop

package/dist/dime.js

@@ -27,8 +27,18 @@ function dimeXmlBytes(contentType, bytes) {
         return bytes;
     const parts = parseMultipartRelated(bytes, boundary);
     const xmlParts = parts.filter((p) => isXmlContentType(p.contentType));
-    if (xmlParts.length === 0)
-        throw new Error("DIME response missing text/xml part");
+    if (xmlParts.length === 0) {
+        // Some CUCM versions have been observed returning multipart bodies where the XML part
+        // does not advertise a classic XML content-type. Fall back to sniffing the payload.
+        const sniffed = parts.find((p) => {
+            const head = p.body.subarray(0, 64).toString("utf8");
+            return head.includes("<?xml") || head.trimStart().startsWith("<");
+        });
+        if (sniffed)
+            return sniffed.body;
+        const partTypes = parts.map((p) => p.contentType).join(", ");
+        throw new Error(`DIME response missing text/xml part (boundary=${boundary}; parts=[${partTypes || "none"}])`);
+    }
     return xmlParts[0].body;
 }
 export function normalizeHost(hostOrUrl) {

package/dist/index.js

@@ -14,7 +14,7 @@ const strictTls = tlsMode === "strict" || tlsMode === "verify";
 // Set CUCM_MCP_TLS_MODE=strict to enforce verification.
 if (!strictTls)
     process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
-const server = new McpServer({ name: "cucm", version: "0.1.3" });
+const server = new McpServer({ name: "cucm", version: "0.1.4" });
 const captures = new PacketCaptureManager();
 const captureState = defaultStateStore();
 const dimeAuthSchema = z
@@ -106,21 +106,42 @@ server.tool("packet_capture_start", "Start a packet capture on CUCM via SSH (uti
     auth: sshAuthSchema,
     iface: z.string().optional().describe("Interface (default eth0)"),
     fileBase: z.string().optional().describe("Capture base name (no dots). Saved as <fileBase>.cap"),
-    count: z.number().int().min(1).max(200000).optional().describe("Packet count (file max is typically 100000)"),
+    count: z.number().int().min(1).max(1_000_000).optional().describe("Packet count (common max is 1000000)"),
+    maxPackets: z
+        .boolean()
+        .optional()
+        .describe("If true and count is omitted, uses a high capture count (1,000,000)"),
     size: z.string().optional().describe("Packet size (e.g. all)"),
     hostFilterIp: z.string().optional().describe("Optional filter: host ip <addr>"),
     portFilter: z.number().int().min(1).max(65535).optional().describe("Optional filter: port <num>"),
-}, async ({ host, sshPort, auth, iface, fileBase, count, size, hostFilterIp, portFilter }) => {
+    maxDurationMs: z
+        .number()
+        .int()
+        .min(250)
+        .max(24 * 60 * 60_000)
+        .optional()
+        .describe("Stop after this duration even if packet count isn't reached"),
+    startTimeoutMs: z
+        .number()
+        .int()
+        .min(2000)
+        .max(120_000)
+        .optional()
+        .describe("Timeout for starting capture (SSH connect + command start)"),
+}, async ({ host, sshPort, auth, iface, fileBase, count, maxPackets, size, hostFilterIp, portFilter, maxDurationMs, startTimeoutMs }) => {
+    const resolvedCount = count ?? (maxPackets ? 1_000_000 : undefined);
     const result = await captures.start({
         host,
         sshPort,
         auth: auth,
         iface,
         fileBase,
-        count,
+        count: resolvedCount,
         size,
         hostFilterIp,
         portFilter,
+        maxDurationMs,
+        startTimeoutMs,
     });
     return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
 });

package/dist/packetCapture.js

@@ -90,6 +90,33 @@ export function remoteCaptureCandidates(fileBase, maxParts = 10) {
     }
     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?.();
+    });
+}
 export class PacketCaptureManager {
     active = new Map();
     state;
@@ -136,8 +163,10 @@ export class PacketCaptureManager {
                 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.exec(cmd, { pty: true }, (err, ch) => {
+            client.shell({ term: "vt100", cols: 120, rows: 40 }, (err, ch) => {
                 if (err)
                     return reject(err);
                 resolve(ch);
@@ -165,7 +194,62 @@ export class PacketCaptureManager {
                 // 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?.();
+        }
         return session;
     }
     async stop(captureId, timeoutMs = 90_000) {
@@ -174,6 +258,9 @@ export class PacketCaptureManager {
             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 = () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@calltelemetry/cucm-mcp",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "private": false,
   "type": "module",
   "description": "MCP server for CUCM tooling (DIME logs, syslog, packet capture)",