@calltelemetry/cucm-mcp 0.1.3 → 0.1.4

package/README.md

@@ -84,3 +84,8 @@ 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`

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,18 +106,23 @@ 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 }) => {
+}, async ({ host, sshPort, auth, iface, fileBase, count, maxPackets, size, hostFilterIp, portFilter }) => {
+    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,

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,6 +194,28 @@ export class PacketCaptureManager {
                 // ignore
             }
         });
+        // Wait for prompt before running capture command.
+        try {
+            await waitFor(channel, session, () => looksLikeCucmPrompt(session.lastStdout) || looksLikeCucmPrompt(session.lastStderr), 30_000, "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 });
         return session;
     }
@@ -174,6 +225,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.4",
   "private": false,
   "type": "module",
   "description": "MCP server for CUCM tooling (DIME logs, syslog, packet capture)",