@fitchmultz/pi-mcp-adapter 8.0.5 → 8.0.7

package/dist/mcp-output-guard.js

@@ -44,12 +44,19 @@ export async function guardMcpOutput(content, options = {}) {
     const normalizedContent = withEmptyTextFallback(content.length > 0
         ? sanitizeContent(content)
         : [{ type: "text", text: options.emptyTextFallback ?? "(empty result)" }], options.emptyTextFallback);
-    const retained = options.retainedMcpResult ?? (options.rawMcpResult === undefined ? {} : await retainMcpResult(options.rawMcpResult, options));
-    const reference = retained.resultRef ? formatMcpResultReference(retained.resultRef)
-        : retained.resultWriteError ? `[MCP result could not be saved: ${retained.resultWriteError}]` : undefined;
+    const retained = options.retainedMcpResult ??
+        (options.rawMcpResult === undefined
+            ? {}
+            : await retainMcpResult(options.rawMcpResult, options));
+    const reference = retained.resultRef
+        ? formatMcpResultReference(retained.resultRef)
+        : retained.resultWriteError
+            ? `[MCP result could not be saved: ${retained.resultWriteError}]`
+            : undefined;
     const withReference = (blocks) => reference ? [...blocks, { type: "text", text: reference }] : blocks;
-    if (options.enabled === false)
+    if (options.enabled === false) {
         return { content: withReference(addAffixes(normalizedContent, prefix, suffix)), ...retained };
+    }
     const imageBlocks = normalizedContent.filter((block) => block.type === "image");
     const textOutput = normalizedContent
         .filter((block) => block.type === "text")
@@ -58,7 +65,7 @@ export async function guardMcpOutput(content, options = {}) {
     const composedOutput = `${prefix}${textOutput}${suffix}`;
     const stats = textStats(composedOutput);
     const referenceSuffix = reference ? `\n${reference}` : "";
-    const totalStats = textStats(composedOutput ? composedOutput + referenceSuffix : reference ?? "");
+    const totalStats = textStats(composedOutput ? composedOutput + referenceSuffix : (reference ?? ""));
     let guardedContent = addAffixes(normalizedContent, prefix, suffix);
     let outputGuard;
     if (totalStats.bytes > maxBytes || totalStats.lines > maxLines) {
@@ -72,19 +79,22 @@ export async function guardMcpOutput(content, options = {}) {
     };
 }
 function withEmptyTextFallback(content, fallback) {
-    if (!fallback)
+    if (!fallback) {
         return content;
+    }
     const textOutput = content
         .filter((block) => block.type === "text")
         .map((block) => block.text)
         .join("\n");
-    if (textOutput)
+    if (textOutput) {
         return content;
+    }
     return [{ type: "text", text: fallback }, ...content.filter((block) => block.type === "image")];
 }
 function addAffixes(content, prefix, suffix) {
-    if (!prefix && !suffix)
+    if (!prefix && !suffix) {
         return content;
+    }
     const next = [...content];
     if (prefix) {
         const index = next.findIndex((block) => block.type === "text");
@@ -123,26 +133,47 @@ export async function retainMcpResult(result, options = {}, rawResult = false) {
     const raw = safeStringify(result);
     const rawBytes = byteLength(raw);
     const record = asRecord(result);
-    const content = Array.isArray(record?.content) ? record.content
-        : Array.isArray(record?.contents) ? record.contents.map(resource => ({ type: "resource", resource })) : [];
-    const payloadFiles = (await Promise.all(content.map(async (block, index) => {
-        const item = asRecord(block);
-        const resource = asRecord(item?.resource);
-        const data = item?.type === "audio" ? item.data : item?.type === "resource" ? resource?.blob : undefined;
-        if (typeof data !== "string")
-            return undefined;
-        const mimeType = item?.mimeType ?? resource?.mimeType;
-        return { index, kind: item.type, ...(typeof resource?.uri === "string" ? { uri: resource.uri } : {}), ...(typeof mimeType === "string" ? { mimeType } : {}), ...await saveArtifact("payload", Buffer.from(data, "base64"), options.outputDirectory) };
-    }))).filter((file) => file !== undefined);
-    const oversized = options.enabled !== false && rawBytes > (options.detailsMaxBytes ?? DEFAULT_MCP_DETAILS_MAX_BYTES);
-    const shouldSave = oversized || !record || Object.keys(record).some(key => key !== "content" && key !== "isError")
-        || content.some(block => {
+    const content = Array.isArray(record?.content)
+        ? record.content
+        : Array.isArray(record?.contents)
+            ? record.contents.map((resource) => ({ type: "resource", resource }))
+            : [];
+    const oversized = options.enabled !== false &&
+        rawBytes > (options.detailsMaxBytes ?? DEFAULT_MCP_DETAILS_MAX_BYTES);
+    const shouldSave = oversized ||
+        !record ||
+        Object.keys(record).some((key) => key !== "content" && key !== "isError") ||
+        content.some((block) => {
             const item = asRecord(block);
-            return item?.type !== "text" || Object.keys(item).some(key => key !== "type" && key !== "text");
+            return (item?.type !== "text" || Object.keys(item).some((key) => key !== "type" && key !== "text"));
         });
-    if (!shouldSave)
+    if (!shouldSave) {
         return { mcpResult: result };
-    const artifact = await saveArtifact("mcp-result", raw, options.outputDirectory);
+    }
+    const [rawPayloadFiles, artifact] = await Promise.all([
+        Promise.all(content.map(async (block, index) => {
+            const item = asRecord(block);
+            const resource = asRecord(item?.resource);
+            const data = item?.type === "audio"
+                ? item.data
+                : item?.type === "resource"
+                    ? resource?.blob
+                    : undefined;
+            if (typeof data !== "string") {
+                return undefined;
+            }
+            const mimeType = item?.mimeType ?? resource?.mimeType;
+            return {
+                index,
+                kind: item.type,
+                ...(typeof resource?.uri === "string" ? { uri: resource.uri } : {}),
+                ...(typeof mimeType === "string" ? { mimeType } : {}),
+                ...(await saveArtifact("payload", Buffer.from(data, "base64"), options.outputDirectory)),
+            };
+        })),
+        saveArtifact("mcp-result", raw, options.outputDirectory),
+    ]);
+    const payloadFiles = rawPayloadFiles.filter((file) => file !== undefined);
     return {
         mcpResult: oversized && !rawResult ? summarizeMcpResult(result, rawBytes, artifact) : result,
         ...(artifact.path ? { resultRef: artifact.path } : {}),
@@ -181,26 +212,49 @@ function summarizeMcpResult(result, rawBytes, artifact) {
         const extraFields = Object.keys(record)
             .filter((key) => !standard.has(key))
             .slice(0, KEY_PREVIEW_LIMIT)
-            .map((key) => ({ key: truncateKey(key), type: typeof record[key], estimatedBytes: estimateValueBytes(record[key]), omitted: true }));
-        if (extraFields.length > 0)
+            .map((key) => ({
+            key: truncateKey(key),
+            type: typeof record[key],
+            estimatedBytes: estimateValueBytes(record[key]),
+            omitted: true,
+        }));
+        if (extraFields.length > 0) {
             summary.extraFields = extraFields;
+        }
     }
     return summary;
 }
 function summarizeContent(content) {
-    const summaries = content.slice(0, CONTENT_SUMMARY_LIMIT).map((block) => {
+    const summaries = content
+        .slice(0, CONTENT_SUMMARY_LIMIT)
+        .map((block) => {
         const record = asRecord(block);
-        if (!record)
+        if (!record) {
             return { type: typeof block, omitted: true };
+        }
         if (record.type === "text") {
             const text = typeof record.text === "string" ? record.text : "";
-            return { type: "text", bytes: byteLength(text), lines: textStats(text).lines, textOmitted: true };
+            return {
+                type: "text",
+                bytes: byteLength(text),
+                lines: textStats(text).lines,
+                textOmitted: true,
+            };
         }
         if (record.type === "image") {
             const data = typeof record.data === "string" ? record.data : "";
-            return { type: "image", mimeType: typeof record.mimeType === "string" ? record.mimeType : undefined, dataBytes: byteLength(data), dataOmitted: true };
+            return {
+                type: "image",
+                mimeType: typeof record.mimeType === "string" ? record.mimeType : undefined,
+                dataBytes: byteLength(data),
+                dataOmitted: true,
+            };
         }
-        return { type: typeof record.type === "string" ? record.type : "unknown", estimatedBytes: estimateValueBytes(record), omitted: true };
+        return {
+            type: typeof record.type === "string" ? record.type : "unknown",
+            estimatedBytes: estimateValueBytes(record),
+            omitted: true,
+        };
     });
     if (content.length > CONTENT_SUMMARY_LIMIT) {
         summaries.push({ type: "omitted", count: content.length - CONTENT_SUMMARY_LIMIT });
@@ -210,7 +264,11 @@ function summarizeContent(content) {
 function summarizeValue(value) {
     const record = asRecord(value);
     if (!record) {
-        return { type: value === null ? "null" : typeof value, estimatedBytes: estimateValueBytes(value), omitted: true };
+        return {
+            type: value === null ? "null" : typeof value,
+            estimatedBytes: estimateValueBytes(value),
+            omitted: true,
+        };
     }
     const keys = Object.keys(record);
     return {
@@ -222,16 +280,22 @@ function summarizeValue(value) {
     };
 }
 function estimateValueBytes(value, depth = 0) {
-    if (value === null || value === undefined)
+    if (value === null || value === undefined) {
         return 0;
-    if (typeof value === "string")
+    }
+    if (typeof value === "string") {
         return byteLength(value);
-    if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint")
+    }
+    if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
         return byteLength(String(value));
+    }
     const record = asRecord(value);
-    if (!record || depth >= 2)
+    if (!record || depth >= 2) {
         return 0;
-    const values = Array.isArray(value) ? value.slice(0, KEY_PREVIEW_LIMIT) : Object.values(record).slice(0, KEY_PREVIEW_LIMIT);
+    }
+    const values = Array.isArray(value)
+        ? value.slice(0, KEY_PREVIEW_LIMIT)
+        : Object.values(record).slice(0, KEY_PREVIEW_LIMIT);
     return values.reduce((total, item) => total + estimateValueBytes(item, depth + 1), 0);
 }
 function truncateKey(key) {
@@ -240,8 +304,9 @@ function truncateKey(key) {
 async function saveArtifact(kind, text, outputDirectory) {
     try {
         const parent = outputDirectory === undefined ? tmpdir() : resolve(outputDirectory);
-        if (outputDirectory !== undefined)
+        if (outputDirectory !== undefined) {
             await mkdir(parent, { recursive: true, mode: 0o700 });
+        }
         const dir = await mkdtemp(join(parent, "pi-mcp-output-"));
         const path = join(dir, `${kind}-${randomBytes(4).toString("hex")}.${typeof text === "string" ? "txt" : "bin"}`);
         await writeFile(path, text, { encoding: "utf8", mode: 0o600 });
@@ -254,13 +319,15 @@ async function saveArtifact(kind, text, outputDirectory) {
 /** Stream histories through the same private output-artifact and paged-reader boundary. */
 export async function saveMcpOutputStream(chunks, outputDirectory) {
     const artifact = await saveArtifact("output", "", outputDirectory);
-    if (!artifact.path)
+    if (!artifact.path) {
         return artifact;
+    }
     try {
         const file = await open(artifact.path, "a");
         try {
-            for await (const chunk of chunks)
+            for await (const chunk of chunks) {
                 await file.writeFile(chunk);
+            }
         }
         finally {
             await file.close();
@@ -273,47 +340,85 @@ export async function saveMcpOutputStream(chunks, outputDirectory) {
 }
 export async function readMcpResult(input, options = {}) {
     try {
-        if (!input || typeof input.ref !== "string")
+        if (!input || typeof input.ref !== "string") {
             throw new Error("ref must be a retained MCP result path");
+        }
         // Script-only hosts deliberately have no general filesystem capability.
-        const root = await realpath(options.outputDirectory === undefined ? tmpdir() : resolve(options.outputDirectory));
-        const ref = await realpath(resolve(input.ref));
-        if (dirname(dirname(ref)) !== root || !/^pi-mcp-output-/.test(basename(dirname(ref)))
-            || !/^(mcp-result|output)-[a-f0-9]+\.txt$/.test(basename(ref)))
+        const [root, ref] = await Promise.all([
+            realpath(options.outputDirectory === undefined ? tmpdir() : resolve(options.outputDirectory)),
+            realpath(resolve(input.ref)),
+        ]);
+        if (dirname(dirname(ref)) !== root ||
+            !basename(dirname(ref)).startsWith("pi-mcp-output-") ||
+            !/^(mcp-result|output)-[a-f0-9]+\.txt$/.test(basename(ref))) {
             throw new Error("ref is not an MCP output artifact in this host's output directory");
+        }
         // Plain output pages without flattening a complete UI history into memory.
-        if (basename(ref).startsWith("output-") && input.path === undefined && input.fields === undefined) {
+        if (basename(ref).startsWith("output-") &&
+            input.path === undefined &&
+            input.fields === undefined) {
             const offset = input.offset ?? 0;
             const limit = input.limit ?? 12_000;
-            if (!Number.isSafeInteger(offset) || offset < 0 || !Number.isSafeInteger(limit) || limit < 1)
+            if (!Number.isSafeInteger(offset) ||
+                offset < 0 ||
+                !Number.isSafeInteger(limit) ||
+                limit < 1) {
                 throw new Error("offset must be a non-negative integer and limit a positive integer");
+            }
             const maxBytes = Math.max(1, (options.maxBytes ?? DEFAULT_MCP_OUTPUT_MAX_BYTES) - 256);
             const maxLines = Math.max(1, (options.maxLines ?? DEFAULT_MCP_OUTPUT_MAX_LINES) - 1);
             const { page, total } = await readPlainResult(ref, offset, limit, maxBytes, maxLines);
             const end = offset + page.length;
             const nextOffset = end < total ? end : null;
-            return { content: [{ type: "text", text: page }, ...(nextOffset !== null ? [{ type: "text", text: `[MCP result page: ${offset}–${end} of ${total} characters. Continue with offset: ${end}.]` }] : [])], details: { ref, offset, nextOffset, totalCharacters: total } };
+            return {
+                content: [
+                    { type: "text", text: page },
+                    ...(nextOffset !== null
+                        ? [
+                            {
+                                type: "text",
+                                text: `[MCP result page: ${offset}–${end} of ${total} characters. Continue with offset: ${end}.]`,
+                            },
+                        ]
+                        : []),
+                ],
+                details: { ref, offset, nextOffset, totalCharacters: total },
+            };
         }
         let rendered = await readFile(ref, "utf8");
-        if (input.path !== undefined || input.fields !== undefined || basename(ref).startsWith("mcp-result-")) {
+        if (input.path !== undefined ||
+            input.fields !== undefined ||
+            basename(ref).startsWith("mcp-result-")) {
             let value = JSON.parse(rendered);
             if (input.path !== undefined && input.path !== "") {
-                if (typeof input.path !== "string" || !input.path.startsWith("/") || /~(?:[^01]|$)/.test(input.path))
+                if (typeof input.path !== "string" ||
+                    !input.path.startsWith("/") ||
+                    /~(?:[^01]|$)/.test(input.path)) {
                     throw new Error("path must be an RFC 6901 JSON Pointer");
+                }
                 for (const token of input.path.slice(1).split("/")) {
                     const key = token.replace(/~1/g, "/").replace(/~0/g, "~");
-                    if (value === null || typeof value !== "object" || (Array.isArray(value) && !/^(0|[1-9]\d*)$/.test(key)) || !Object.hasOwn(value, key))
+                    if (value === null ||
+                        typeof value !== "object" ||
+                        (Array.isArray(value) && !/^(0|[1-9]\d*)$/.test(key)) ||
+                        !Object.hasOwn(value, key)) {
                         throw new Error(`JSON Pointer does not exist: ${input.path}`);
+                    }
                     value = value[key];
                 }
             }
             if (input.fields !== undefined) {
-                if (!Array.isArray(input.fields) || input.fields.some(field => typeof field !== "string"))
+                if (!Array.isArray(input.fields) ||
+                    input.fields.some((field) => typeof field !== "string")) {
                     throw new Error("fields must be an array of keys");
+                }
                 const select = (item) => {
-                    if (!item || typeof item !== "object" || Array.isArray(item))
+                    if (!item || typeof item !== "object" || Array.isArray(item)) {
                         throw new Error("fields requires an object or array of objects");
-                    return Object.fromEntries(input.fields.filter(key => Object.hasOwn(item, key)).map(key => [key, item[key]]));
+                    }
+                    return Object.fromEntries(input
+                        .fields.filter((key) => Object.hasOwn(item, key))
+                        .map((key) => [key, item[key]]));
                 };
                 value = Array.isArray(value) ? value.map(select) : select(value);
             }
@@ -321,10 +426,12 @@ export async function readMcpResult(input, options = {}) {
         }
         const offset = input.offset ?? 0;
         const limit = input.limit ?? 12_000;
-        if (!Number.isSafeInteger(offset) || offset < 0 || !Number.isSafeInteger(limit) || limit < 1)
+        if (!Number.isSafeInteger(offset) || offset < 0 || !Number.isSafeInteger(limit) || limit < 1) {
             throw new Error("offset must be a non-negative integer and limit a positive integer");
-        if (offset > 0 && rendered.codePointAt(offset - 1) > 0xffff)
+        }
+        if (offset > 0 && rendered.codePointAt(offset - 1) > 0xffff) {
             throw new Error("offset must not split a Unicode surrogate pair");
+        }
         const maxBytes = options.maxBytes ?? DEFAULT_MCP_OUTPUT_MAX_BYTES;
         const maxLines = options.maxLines ?? DEFAULT_MCP_OUTPUT_MAX_LINES;
         const notice = (end) => `[MCP result page: ${offset}–${end} of ${rendered.length} characters. Continue with offset: ${end}.]`;
@@ -336,11 +443,13 @@ export async function readMcpResult(input, options = {}) {
                 const width = rendered.codePointAt(end) > 0xffff ? 2 : 1;
                 const char = rendered.slice(end, end + width);
                 bytes += byteLength(char);
-                if (char === "\n")
+                if (char === "\n") {
                     lines++;
+                }
                 // Tiny caps still return one complete character plus recovery guidance.
-                if (end > offset && (bytes > byteCap || lines > lineCap || end + width - offset > limit))
+                if (end > offset && (bytes > byteCap || lines > lineCap || end + width - offset > limit)) {
                     break;
+                }
                 end += width;
             }
             return end;
@@ -351,11 +460,26 @@ export async function readMcpResult(input, options = {}) {
             end = pageEnd(maxBytes - byteLength(notice(rendered.length)) - 1, maxLines - 1);
         }
         const nextOffset = end < rendered.length ? end : null;
-        return { content: [{ type: "text", text: rendered.slice(offset, end) }, ...(nextOffset !== null ? [{ type: "text", text: notice(end) }] : [])], details: { ref, offset, nextOffset, totalCharacters: rendered.length, ...(input.path !== undefined ? { path: input.path } : {}) } };
+        return {
+            content: [
+                { type: "text", text: rendered.slice(offset, end) },
+                ...(nextOffset !== null ? [{ type: "text", text: notice(end) }] : []),
+            ],
+            details: {
+                ref,
+                offset,
+                nextOffset,
+                totalCharacters: rendered.length,
+                ...(input.path !== undefined ? { path: input.path } : {}),
+            },
+        };
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        return { content: [{ type: "text", text: message }], details: { error: "result_read_failed", message } };
+        return {
+            content: [{ type: "text", text: message }],
+            details: { error: "result_read_failed", message },
+        };
     }
 }
 function asRecord(value) {
@@ -371,18 +495,22 @@ function safeStringify(value) {
     }
 }
 function positiveInt(value) {
-    if (typeof value !== "number" || !Number.isFinite(value))
+    if (typeof value !== "number" || !Number.isFinite(value)) {
         return undefined;
+    }
     const integer = Math.floor(value);
     return integer > 0 ? integer : undefined;
 }
 function envKillSwitch(name) {
     const value = process.env[name]?.trim().toLowerCase();
-    if (!value)
+    if (!value) {
         return undefined;
-    if (["0", "false", "no", "off"].includes(value))
+    }
+    if (["0", "false", "no", "off"].includes(value)) {
         return false;
-    if (["1", "true", "yes", "on"].includes(value))
+    }
+    if (["1", "true", "yes", "on"].includes(value)) {
         return true;
+    }
     return undefined;
 }

package/dist/mcp-output-preview.js

@@ -20,14 +20,17 @@ export function createMcpOutputSpool(options) {
     let artifact = {};
     let fd;
     let pending = [], pendingLength = 0;
-    const lines = () => bytes === 0 ? 0 : newlines + 1;
+    const lines = () => (bytes === 0 ? 0 : newlines + 1);
     const fail = (error) => {
         artifact = { error: error instanceof Error ? error.message : String(error) };
-        if (fd !== undefined)
+        if (fd !== undefined) {
             try {
                 closeSync(fd);
             }
-            catch { /* the write error is the reported failure */ }
+            catch {
+                /* the write error is the reported failure */
+            }
+        }
         fd = undefined;
     };
     const flush = () => {
@@ -47,29 +50,34 @@ export function createMcpOutputSpool(options) {
             // Each UTF-16 unit is at least one UTF-8 byte, so the head exceeds every preview budget.
             let end = Math.min(piece.length, maxBytes + 1 - headBytes);
             const last = piece.charCodeAt(end - 1);
-            if (end < piece.length && last >= 0xd800 && last <= 0xdbff)
+            if (end < piece.length && last >= 0xd800 && last <= 0xdbff) {
                 end++;
+            }
             const part = piece.slice(0, end);
             head += part;
             headBytes += byteLength(part);
         }
-        if (fd === undefined)
+        if (fd === undefined) {
             return;
-        if (pendingLength + piece.length > SPOOL_WRITE_CHUNK)
+        }
+        if (pendingLength + piece.length > SPOOL_WRITE_CHUNK) {
             flush();
+        }
         pending.push(piece);
         pendingLength += piece.length;
     };
     const appendText = (text) => {
-        if (written++ > 0)
+        if (written++ > 0) {
             append("\n");
+        }
         append(text);
     };
     const spill = (blocks) => {
         try {
             const parent = options.outputDirectory === undefined ? tmpdir() : resolve(options.outputDirectory);
-            if (options.outputDirectory !== undefined)
+            if (options.outputDirectory !== undefined) {
                 mkdirSync(parent, { recursive: true, mode: 0o700 });
+            }
             const path = join(mkdtempSync(join(parent, "pi-mcp-output-")), `output-${randomBytes(4).toString("hex")}.txt`);
             fd = openSync(path, "wx", 0o600);
             artifact = { path };
@@ -78,14 +86,18 @@ export function createMcpOutputSpool(options) {
             fail(error);
         }
         for (const block of blocks) {
-            if (block.type === "image")
+            if (block.type === "image") {
                 images.push(block);
-            else
+            }
+            else {
                 appendText(block.text);
+            }
         }
     };
     return {
-        get empty() { return pushed === 0; },
+        get empty() {
+            return pushed === 0;
+        },
         push(block) {
             pushed++;
             if (block.type === "image") {
@@ -95,8 +107,9 @@ export function createMcpOutputSpool(options) {
             const separator = textBlocks++ > 0 ? 1 : 0;
             bytes += separator + byteLength(block.text);
             newlines += separator + countNewlines(block.text);
-            if (!retained)
+            if (!retained) {
                 appendText(block.text);
+            }
             else {
                 retained.push(block);
                 if (options.enabled !== false && (bytes > maxBytes || lines() > maxLines)) {
@@ -107,8 +120,9 @@ export function createMcpOutputSpool(options) {
             }
         },
         finish() {
-            if (retained)
+            if (retained) {
                 return { content: retained };
+            }
             flush();
             if (fd !== undefined) {
                 try {
@@ -145,14 +159,16 @@ export function truncatedOutput(text, stats, { path: fullOutputPath, error: writ
 }
 function countNewlines(text) {
     let count = 0;
-    for (let index = text.indexOf("\n"); index !== -1; index = text.indexOf("\n", index + 1))
+    for (let index = text.indexOf("\n"); index !== -1; index = text.indexOf("\n", index + 1)) {
         count++;
+    }
     return count;
 }
 export function sanitizeContent(content) {
     return content.map((block) => {
-        if (block.type !== "image")
+        if (block.type !== "image") {
             return block;
+        }
         const mimeType = typeof block.mimeType === "string" && block.mimeType.trim()
             ? block.mimeType.trim().slice(0, 100)
             : "image/png";
@@ -171,8 +187,9 @@ function truncateHead(text, maxBytes, maxLines) {
     const output = [];
     let bytes = 0;
     for (const line of lines) {
-        if (output.length >= maxLines)
+        if (output.length >= maxLines) {
             break;
+        }
         const separatorBytes = output.length > 0 ? 1 : 0;
         const lineBytes = byteLength(line);
         if (bytes + separatorBytes + lineBytes > maxBytes) {
@@ -190,12 +207,14 @@ function truncateHead(text, maxBytes, maxLines) {
     return { content, bytes: stats.bytes, lines: stats.lines };
 }
 function truncateStringToBytes(value, maxBytes) {
-    if (byteLength(value) <= maxBytes)
+    if (byteLength(value) <= maxBytes) {
         return value;
+    }
     const buffer = Buffer.from(value, "utf8");
     let end = Number.isFinite(maxBytes) ? Math.max(0, Math.floor(maxBytes)) : 0;
-    while (end > 0 && (buffer.readUInt8(end) & 0xc0) === 0x80)
+    while (end > 0 && (buffer.readUInt8(end) & 0xc0) === 0x80) {
         end--;
+    }
     return buffer.subarray(0, end).toString("utf8");
 }
 function formatTruncationNotice(stats, fullOutputPath, writeError) {
@@ -212,9 +231,11 @@ export function byteLength(text) {
     return Buffer.byteLength(text, "utf8");
 }
 function formatSize(bytes) {
-    if (bytes < 1024)
+    if (bytes < 1024) {
         return `${bytes} B`;
-    if (bytes < 1024 * 1024)
+    }
+    if (bytes < 1024 * 1024) {
         return `${(bytes / 1024).toFixed(1)} KiB`;
+    }
     return `${(bytes / (1024 * 1024)).toFixed(1)} MiB`;
 }

package/dist/mcp-panel.d.ts

@@ -2,9 +2,9 @@ import { type PanelKeybindings } from "./panel-keys.ts";
 import type { McpConfig, McpPanelCallbacks, McpPanelResult, ServerProvenance } from "./types.ts";
 import { type MetadataCache } from "./metadata-cache.ts";
 declare class McpPanel {
-    private noticeLines;
-    private prefix;
-    private servers;
+    private readonly noticeLines;
+    private readonly prefix;
+    private readonly servers;
     private cursorIndex;
     private nameQuery;
     private descSearchActive;
@@ -17,14 +17,14 @@ declare class McpPanel {
     private authInFlight;
     private inactivityTimeout;
     private visibleItems;
-    private tui;
-    private t;
-    private authOnly;
-    private keys;
+    private readonly tui;
+    private readonly t;
+    private readonly authOnly;
+    private readonly keys;
     private static readonly MAX_VISIBLE;
     private static readonly INACTIVITY_MS;
-    private callbacks;
-    private done;
+    private readonly callbacks;
+    private readonly done;
     constructor(config: McpConfig, cache: MetadataCache | null, provenance: Map<string, ServerProvenance>, callbacks: McpPanelCallbacks, tui: {
         requestRender(): void;
     }, done: (result: McpPanelResult) => void, options?: {