@fitchmultz/pi-mcp-adapter 8.0.5 → 8.0.7

package/dist/npx-resolver.js

@@ -1,5 +1,5 @@
 // npx-resolver.ts - Resolve npx/npm exec binaries to avoid npm parent processes
-import { existsSync, readFileSync, realpathSync, readdirSync, statSync, writeFileSync, renameSync, mkdirSync, openSync, readSync, closeSync } from "node:fs";
+import { existsSync, readFileSync, realpathSync, readdirSync, statSync, writeFileSync, renameSync, mkdirSync, openSync, readSync, closeSync, } from "node:fs";
 import { join, dirname, extname, resolve, sep } from "node:path";
 import { getAdapterPath } from "./agent-dir.js";
 import { throwIfAborted } from "./abort.js";
@@ -9,23 +9,21 @@ const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
 const EXACT_PACKAGE_VERSION_RE = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z][0-9A-Za-z.-]*)?(?:\+[0-9A-Za-z][0-9A-Za-z.-]*)?$/;
 export async function resolveNpxBinary(command, args, signal) {
     throwIfAborted(signal);
-    const parsed = command === "npx"
-        ? parseNpxArgs(args)
-        : command === "npm"
-            ? parseNpmExecArgs(args)
-            : null;
-    if (!parsed)
+    const parsed = command === "npx" ? parseNpxArgs(args) : command === "npm" ? parseNpmExecArgs(args) : null;
+    if (!parsed) {
         return null;
+    }
     const packageSpec = parsePackageSpec(parsed.packageSpec);
-    if (!packageSpec)
+    if (!packageSpec) {
         return null;
+    }
     const cacheKey = JSON.stringify([command, ...args]);
     const cache = loadCache();
     const cached = cache?.entries?.[cacheKey];
-    if (cached
-        && Date.now() - cached.resolvedAt < CACHE_TTL_MS
-        && existsSync(cached.resolvedBin)
-        && (!packageSpec.exactVersion || cached.packageVersion === packageSpec.exactVersion)) {
+    if (cached &&
+        Date.now() - cached.resolvedAt < CACHE_TTL_MS &&
+        existsSync(cached.resolvedBin) &&
+        (!packageSpec.exactVersion || cached.packageVersion === packageSpec.exactVersion)) {
         return { binPath: cached.resolvedBin, extraArgs: parsed.extraArgs, isJs: cached.isJs };
     }
     const resolved = resolveFromNpmCache(parsed.packageSpec, parsed.binName);
@@ -38,7 +36,11 @@ export async function resolveNpxBinary(command, args, signal) {
     const resolvedAfterInstall = resolveFromNpmCache(parsed.packageSpec, parsed.binName);
     if (resolvedAfterInstall) {
         saveCacheEntry(cacheKey, resolvedAfterInstall);
-        return { binPath: resolvedAfterInstall.resolvedBin, extraArgs: parsed.extraArgs, isJs: resolvedAfterInstall.isJs };
+        return {
+            binPath: resolvedAfterInstall.resolvedBin,
+            extraArgs: parsed.extraArgs,
+            isJs: resolvedAfterInstall.isJs,
+        };
     }
     return null;
 }
@@ -52,30 +54,36 @@ function parseNpxArgs(args) {
     let foundFirstPositional = false;
     for (let i = 0; i < before.length; i++) {
         const arg = before[i];
-        if (arg === undefined)
+        if (arg === undefined) {
             return null;
+        }
         if (foundFirstPositional) {
             positionals.push(arg);
             continue;
         }
-        if (arg === "-y" || arg === "--yes")
+        if (arg === "-y" || arg === "--yes") {
             continue;
+        }
         if (arg === "-p" || arg === "--package") {
             const value = before[i + 1];
-            if (!value || value.startsWith("-"))
+            if (!value || value.startsWith("-")) {
                 return null;
-            if (!packageSpec)
+            }
+            if (!packageSpec) {
                 packageSpec = value;
+            }
             sawPackageFlag = true;
             i++;
             continue;
         }
         if (arg.startsWith("--package=")) {
             const value = arg.slice("--package=".length);
-            if (!value)
+            if (!value) {
                 return null;
-            if (!packageSpec)
+            }
+            if (!packageSpec) {
                 packageSpec = value;
+            }
             sawPackageFlag = true;
             continue;
         }
@@ -88,48 +96,58 @@ function parseNpxArgs(args) {
     const separatedAfter = separatorIndex >= 0 && after.length > 0 ? ["--", ...after] : after;
     if (sawPackageFlag) {
         const binName = positionals[0];
-        if (!packageSpec || !binName)
+        if (!packageSpec || !binName) {
             return null;
+        }
         const extraArgs = positionals.slice(1).concat(separatedAfter);
         return { packageSpec, binName, extraArgs };
     }
     const packagePositional = positionals[0];
-    if (!packagePositional)
+    if (!packagePositional) {
         return null;
+    }
     const extraArgs = positionals.slice(1).concat(separatedAfter);
     return { packageSpec: packagePositional, extraArgs };
 }
 function parseNpmExecArgs(args) {
-    if (args[0] !== "exec")
+    if (args[0] !== "exec") {
         return null;
+    }
     const execArgs = args.slice(1);
     const separatorIndex = execArgs.indexOf("--");
-    if (separatorIndex < 0)
+    if (separatorIndex < 0) {
         return null;
+    }
     const before = execArgs.slice(0, separatorIndex);
     const after = execArgs.slice(separatorIndex + 1);
     let packageSpec;
     for (let i = 0; i < before.length; i++) {
         const arg = before[i];
-        if (arg === undefined)
+        if (arg === undefined) {
             return null;
-        if (arg === "-y" || arg === "--yes")
+        }
+        if (arg === "-y" || arg === "--yes") {
             continue;
+        }
         if (arg === "--package") {
             const value = before[i + 1];
-            if (!value || value.startsWith("-"))
+            if (!value || value.startsWith("-")) {
                 return null;
-            if (!packageSpec)
+            }
+            if (!packageSpec) {
                 packageSpec = value;
+            }
             i++;
             continue;
         }
         if (arg.startsWith("--package=")) {
             const value = arg.slice("--package=".length);
-            if (!value)
+            if (!value) {
                 return null;
-            if (!packageSpec)
+            }
+            if (!packageSpec) {
                 packageSpec = value;
+            }
             continue;
         }
         if (arg.startsWith("-")) {
@@ -137,25 +155,30 @@ function parseNpmExecArgs(args) {
         }
     }
     const binName = after[0];
-    if (!packageSpec || !binName)
+    if (!packageSpec || !binName) {
         return null;
+    }
     const extraArgs = after.slice(1);
     return { packageSpec, binName, extraArgs };
 }
 function resolveFromNpmCache(packageSpec, binName) {
     const cacheDir = getNpmCacheDir();
-    if (!cacheDir)
+    if (!cacheDir) {
         return null;
+    }
     const parsedSpec = parsePackageSpec(packageSpec);
-    if (!parsedSpec)
+    if (!parsedSpec) {
         return null;
+    }
     const { packageName, exactVersion } = parsedSpec;
     const packageDir = findCachedPackageDir(cacheDir, packageName, exactVersion);
-    if (!packageDir)
+    if (!packageDir) {
         return null;
+    }
     const packageJsonPath = join(packageDir, "package.json");
-    if (!existsSync(packageJsonPath))
+    if (!existsSync(packageJsonPath)) {
         return null;
+    }
     let pkg = null;
     try {
         pkg = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
@@ -164,8 +187,9 @@ function resolveFromNpmCache(packageSpec, binName) {
         return null;
     }
     const binField = pkg?.bin;
-    if (!binField)
+    if (!binField) {
         return null;
+    }
     const candidates = buildBinCandidates(packageName, binName);
     let chosenBinName;
     let binRel;
@@ -189,15 +213,17 @@ function resolveFromNpmCache(packageSpec, binName) {
             }
         }
     }
-    if (!binRel)
+    if (!binRel) {
         return null;
+    }
     const nodeModulesDir = findNodeModulesDir(packageDir);
     const binLink = chosenBinName ? join(nodeModulesDir, ".bin", chosenBinName) : null;
     let resolvedBin = binLink && existsSync(binLink) ? safeRealpath(binLink) : "";
     if (!resolvedBin) {
         resolvedBin = resolve(packageDir, binRel);
-        if (!existsSync(resolvedBin))
+        if (!existsSync(resolvedBin)) {
             return null;
+        }
     }
     const isJs = detectJsBinary(resolvedBin);
     return {
@@ -236,23 +262,27 @@ async function forceNpxCache(packageSpec, signal) {
         });
     }
     catch (error) {
-        if (signal?.aborted)
+        if (signal?.aborted) {
             throwIfAborted(signal);
+        }
         // Ignore failures, resolution will fall back to original command
     }
     throwIfAborted(signal);
 }
 function buildBinCandidates(packageName, explicitBin) {
     const candidates = [];
-    if (explicitBin)
+    if (explicitBin) {
         candidates.push(explicitBin);
+    }
     if (packageName.startsWith("@")) {
         const namePart = packageName.split("/")[1] ?? "";
         const scopePart = packageName.split("/")[0]?.replace("@", "") ?? "";
-        if (namePart)
+        if (namePart) {
             candidates.push(namePart);
-        if (scopePart && namePart)
+        }
+        if (scopePart && namePart) {
             candidates.push(`${scopePart}-${namePart}`);
+        }
     }
     else {
         candidates.push(packageName);
@@ -261,14 +291,16 @@ function buildBinCandidates(packageName, explicitBin) {
 }
 function parsePackageSpec(spec) {
     const trimmed = spec.trim();
-    if (!trimmed)
+    if (!trimmed) {
         return null;
+    }
     let packageName;
     let requestedVersion;
     if (trimmed.startsWith("@")) {
         const slashIndex = trimmed.indexOf("/");
-        if (slashIndex < 0)
+        if (slashIndex < 0) {
             return null;
+        }
         const atIndex = trimmed.lastIndexOf("@");
         if (atIndex > slashIndex) {
             packageName = trimmed.slice(0, atIndex);
@@ -288,11 +320,13 @@ function parsePackageSpec(spec) {
             packageName = trimmed;
         }
     }
-    if (!packageName)
+    if (!packageName) {
         return null;
+    }
     const normalizedVersion = requestedVersion?.replace(/^=/, "").replace(/^v/i, "");
     // Let npm resolve ranges and tags rather than choosing an arbitrary cached version.
-    if (requestedVersion !== undefined && (!normalizedVersion || !EXACT_PACKAGE_VERSION_RE.test(normalizedVersion))) {
+    if (requestedVersion !== undefined &&
+        (!normalizedVersion || !EXACT_PACKAGE_VERSION_RE.test(normalizedVersion))) {
         return null;
     }
     return {
@@ -309,14 +343,13 @@ function defaultBinName(packageName) {
 }
 function findCachedPackageDir(cacheDir, packageName, exactVersion) {
     const npxDir = join(cacheDir, "_npx");
-    if (!existsSync(npxDir))
+    if (!existsSync(npxDir)) {
         return null;
-    const packagePathParts = packageName.startsWith("@")
-        ? packageName.split("/")
-        : [packageName];
+    }
+    const packagePathParts = packageName.startsWith("@") ? packageName.split("/") : [packageName];
     const candidates = readdirSync(npxDir, { withFileTypes: true })
-        .filter(entry => entry.isDirectory())
-        .map(entry => {
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => {
         const full = join(npxDir, entry.name);
         const mtime = safeStatMtime(full);
         return { name: entry.name, mtime };
@@ -325,13 +358,15 @@ function findCachedPackageDir(cacheDir, packageName, exactVersion) {
     for (const entry of candidates) {
         const pkgDir = join(npxDir, entry.name, "node_modules", ...packagePathParts);
         const packageJsonPath = join(pkgDir, "package.json");
-        if (!existsSync(packageJsonPath))
+        if (!existsSync(packageJsonPath)) {
             continue;
+        }
         if (exactVersion) {
             try {
                 const pkg = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
-                if (pkg.version !== exactVersion)
+                if (pkg.version !== exactVersion) {
                     continue;
+                }
             }
             catch {
                 continue;
@@ -351,8 +386,9 @@ function findNodeModulesDir(packageDir) {
 }
 function detectJsBinary(binPath) {
     const ext = extname(binPath).toLowerCase();
-    if (ext === ".js" || ext === ".mjs" || ext === ".cjs")
+    if (ext === ".js" || ext === ".mjs" || ext === ".cjs") {
         return true;
+    }
     try {
         const fd = openSync(binPath, "r");
         try {
@@ -371,8 +407,9 @@ function detectJsBinary(binPath) {
 }
 let npmCacheDirCached;
 function getNpmCacheDir() {
-    if (npmCacheDirCached !== undefined)
+    if (npmCacheDirCached !== undefined) {
         return npmCacheDirCached;
+    }
     if (process.env.NPM_CONFIG_CACHE) {
         npmCacheDirCached = process.env.NPM_CONFIG_CACHE;
         return npmCacheDirCached;
@@ -397,16 +434,20 @@ function getNpxCachePath() {
 }
 function loadCache() {
     const cachePath = getNpxCachePath();
-    if (!existsSync(cachePath))
+    if (!existsSync(cachePath)) {
         return null;
+    }
     try {
         const raw = JSON.parse(readFileSync(cachePath, "utf-8"));
-        if (!raw || typeof raw !== "object")
+        if (!raw || typeof raw !== "object") {
             return null;
-        if (raw.version !== CACHE_VERSION)
+        }
+        if (raw.version !== CACHE_VERSION) {
             return null;
-        if (!raw.entries || typeof raw.entries !== "object")
+        }
+        if (!raw.entries || typeof raw.entries !== "object") {
             return null;
+        }
         return raw;
     }
     catch {
@@ -417,7 +458,7 @@ function saveCacheEntry(key, entry) {
     const cachePath = getNpxCachePath();
     const dir = dirname(cachePath);
     mkdirSync(dir, { recursive: true });
-    let merged = { version: CACHE_VERSION, entries: {} };
+    const merged = { version: CACHE_VERSION, entries: {} };
     try {
         if (existsSync(cachePath)) {
             const existing = JSON.parse(readFileSync(cachePath, "utf-8"));

package/dist/onboarding-state.js

@@ -11,12 +11,14 @@ export function getOnboardingStatePath() {
 }
 export function loadOnboardingState() {
     const path = getOnboardingStatePath();
-    if (!existsSync(path))
+    if (!existsSync(path)) {
         return { ...DEFAULT_STATE };
+    }
     try {
         const raw = JSON.parse(readFileSync(path, "utf-8"));
-        if (!raw || typeof raw !== "object")
+        if (!raw || typeof raw !== "object") {
             return { ...DEFAULT_STATE };
+        }
         return {
             version: 1,
             sharedConfigHintShown: raw.sharedConfigHintShown === true,

package/dist/plain-result-reader.js

@@ -8,8 +8,11 @@ const readers = new Map();
 const MAX_INDEXES = 8;
 const MAX_POINTS = 1024;
 function sameRevision(a, b) {
-    return a.dev === b.dev && a.ino === b.ino && a.size === b.size
-        && a.mtimeNs === b.mtimeNs && a.ctimeNs === b.ctimeNs;
+    return (a.dev === b.dev &&
+        a.ino === b.ino &&
+        a.size === b.size &&
+        a.mtimeNs === b.mtimeNs &&
+        a.ctimeNs === b.ctimeNs);
 }
 /** Raw full-content SHA-256. Returns "" on a short read so a truncated verify never matches. */
 async function digestOf(file, size) {
@@ -18,16 +21,18 @@ async function digestOf(file, size) {
     let position = 0;
     while (position < size) {
         const { bytesRead } = await file.read(buffer, 0, Math.min(buffer.length, size - position), position);
-        if (!bytesRead)
+        if (!bytesRead) {
             return "";
+        }
         hash.update(buffer.subarray(0, bytesRead));
         position += bytesRead;
     }
     return hash.digest("hex");
 }
 function checkpoint(index, point) {
-    if (point.bytes - index.points.at(-1).bytes < index.stride)
+    if (point.bytes - index.points.at(-1).bytes < index.stride) {
         return;
+    }
     index.points.push(point);
     if (index.points.length > MAX_POINTS) {
         index.points = index.points.filter((_, i) => i % 2 === 0);
@@ -37,8 +42,9 @@ function checkpoint(index, point) {
 function remember(ref, index) {
     indexes.delete(ref);
     indexes.set(ref, index);
-    if (indexes.size > MAX_INDEXES)
+    if (indexes.size > MAX_INDEXES) {
         indexes.delete(indexes.keys().next().value);
+    }
 }
 function extend(index, after, text) {
     // Clone before updating so a shared cached hasher never advances.
@@ -49,8 +55,9 @@ function extend(index, after, text) {
     // Index only the accepted delta, keeping checkpoints on complete UTF-8 code points.
     for (let start = 0; start < text.length;) {
         let end = Math.min(text.length, start + 16 * 1024);
-        if (end < text.length && text.codePointAt(end - 1) > 0xffff)
+        if (end < text.length && text.codePointAt(end - 1) > 0xffff) {
             end++;
+        }
         position += byteLength(text.slice(start, end));
         checkpoint(index, { bytes: position, characters: index.total + end });
         start = end;
@@ -66,32 +73,42 @@ export function appendPlainOutput(ref, text) {
         key = indexes.size || readers.size ? realpathSync(ref) : ref;
         cached = indexes.get(key);
         indexes.delete(key);
-        if (cached || readers.has(key))
+        if (cached || readers.has(key)) {
             before = statSync(ref, { bigint: true });
+        }
+    }
+    catch {
+        /* Cache bookkeeping must not change write acceptance. */
     }
-    catch { /* Cache bookkeeping must not change write acceptance. */ }
     appendFileSync(ref, text, { flush: true });
-    if (!before)
+    if (!before) {
         return;
+    }
     try {
         const after = statSync(ref, { bigint: true });
-        if (after.dev !== before.dev || after.ino !== before.ino
-            || after.size !== before.size + BigInt(byteLength(text)))
+        if (after.dev !== before.dev ||
+            after.ino !== before.ino ||
+            after.size !== before.size + BigInt(byteLength(text))) {
             return;
+        }
         if (cached && sameRevision(cached.revision, before) && !text.includes("\ufffd")) {
             const next = { ...cached, points: [...cached.points] };
             extend(next, after, text);
             remember(key, next);
         }
         for (const progress of readers.get(key) ?? []) {
-            if (!sameRevision(progress.revision, before))
+            if (!sameRevision(progress.revision, before)) {
                 continue;
+            }
             extend(progress, after, text);
-            if (text.includes("\ufffd"))
+            if (text.includes("\ufffd")) {
                 progress.cacheable = false;
+            }
         }
     }
-    catch { /* The durable append already succeeded; leave its index invalidated. */ }
+    catch {
+        /* The durable append already succeeded; leave its index invalidated. */
+    }
 }
 /** Sparse byte/UTF16 checkpoints, never retained file contents. Changed/uncacheable files scan afresh. */
 export async function readPlainResult(ref, offset, limit, maxBytes, maxLines) {
@@ -103,12 +120,25 @@ export async function readPlainResult(ref, offset, limit, maxBytes, maxLines) {
             const revision = fstatSync(file.fd, { bigint: true });
             const cached = indexes.get(ref);
             const matched = cached !== undefined && sameRevision(cached.revision, revision);
-            const fresh = { revision, total: 0, points: [{ bytes: 0, characters: 0 }],
-                stride: 64 * 1024, digest: "", hasher: createHash("sha256") };
+            const fresh = {
+                revision,
+                total: 0,
+                points: [{ bytes: 0, characters: 0 }],
+                stride: 64 * 1024,
+                digest: "",
+                hasher: createHash("sha256"),
+            };
             let index = matched ? cached : fresh;
             // Append characters stay relative until the cold scan knows the opened prefix's total.
-            progress = { revision, total: 0, points: [{ bytes: Number(revision.size), characters: 0 }],
-                stride: index.stride, cacheable: true, digest: "", hasher: index.hasher.copy() };
+            progress = {
+                revision,
+                total: 0,
+                points: [{ bytes: Number(revision.size), characters: 0 }],
+                stride: index.stride,
+                cacheable: true,
+                digest: "",
+                hasher: index.hasher.copy(),
+            };
             const active = readers.get(ref) ?? new Set();
             active.add(progress);
             readers.set(ref, active);
@@ -125,8 +155,9 @@ export async function readPlainResult(ref, offset, limit, maxBytes, maxLines) {
             let point = index.points[0];
             if (valid) {
                 for (const candidate of index.points) {
-                    if (candidate.characters > offset)
+                    if (candidate.characters > offset) {
                         break;
+                    }
                     point = candidate;
                 }
             }
@@ -139,26 +170,31 @@ export async function readPlainResult(ref, offset, limit, maxBytes, maxLines) {
                 let readPosition = point.bytes;
                 while (readPosition < Number(revision.size)) {
                     const { bytesRead } = await file.read(buffer, 0, Math.min(buffer.length, Number(revision.size) - readPosition), readPosition);
-                    if (!bytesRead)
+                    if (!bytesRead) {
                         break;
+                    }
                     readPosition += bytesRead;
-                    const chunk = decoder.write(buffer.subarray(0, bytesRead)) + (readPosition === Number(revision.size) ? decoder.end() : "");
+                    const chunk = decoder.write(buffer.subarray(0, bytesRead)) +
+                        (readPosition === Number(revision.size) ? decoder.end() : "");
                     if (!valid) {
                         progress.hasher.update(buffer.subarray(0, bytesRead));
                         checkpoint(index, { bytes: position, characters: total });
                         // Invalid/incomplete UTF8 can re-decode differently after append. Keep the full-scan fallback.
-                        if (chunk.includes("\ufffd"))
+                        if (chunk.includes("\ufffd")) {
                             cacheable = false;
+                        }
                         position += byteLength(chunk);
                     }
                     const start = Math.max(0, offset - total);
                     if (!finished && start < chunk.length) {
-                        if (start > 0 && chunk.codePointAt(start - 1) > 0xffff)
+                        if (start > 0 && chunk.codePointAt(start - 1) > 0xffff) {
                             throw new Error("offset must not split a Unicode surrogate pair");
+                        }
                         for (const char of chunk.slice(start)) {
                             const nextBytes = bytes + byteLength(char);
                             const nextLines = lines + (char === "\n" ? 1 : 0);
-                            if (page && (nextBytes > maxBytes || nextLines > maxLines || page.length + char.length > limit)) {
+                            if (page &&
+                                (nextBytes > maxBytes || nextLines > maxLines || page.length + char.length > limit)) {
                                 finished = true;
                                 break;
                             }
@@ -168,21 +204,31 @@ export async function readPlainResult(ref, offset, limit, maxBytes, maxLines) {
                         }
                     }
                     total += chunk.length;
-                    if (valid && finished)
+                    if (valid && finished) {
                         break;
+                    }
                 }
             }
             // Only verified native appends may advance this snapshot. External edits still invalidate.
-            if (!sameRevision(progress.revision, statSync(ref, { bigint: true })))
+            if (!sameRevision(progress.revision, statSync(ref, { bigint: true }))) {
                 continue;
-            if (!valid)
+            }
+            if (!valid) {
                 index.total = total;
+            }
             // Serve the opened prefix; retain verified append checkpoints for the next read.
             if (cacheable && progress.cacheable) {
-                const next = { ...index, revision: progress.revision, total: index.total + progress.total,
-                    points: [...index.points], digest: progress.hasher.copy().digest("hex"), hasher: progress.hasher };
-                for (const point of progress.points)
+                const next = {
+                    ...index,
+                    revision: progress.revision,
+                    total: index.total + progress.total,
+                    points: [...index.points],
+                    digest: progress.hasher.copy().digest("hex"),
+                    hasher: progress.hasher,
+                };
+                for (const point of progress.points) {
                     checkpoint(next, { bytes: point.bytes, characters: index.total + point.characters });
+                }
                 remember(ref, next);
             }
             return { page, total: index.total };
@@ -191,8 +237,9 @@ export async function readPlainResult(ref, offset, limit, maxBytes, maxLines) {
             if (progress) {
                 const active = readers.get(ref);
                 active.delete(progress);
-                if (!active.size)
+                if (!active.size) {
                     readers.delete(ref);
+                }
             }
             await file.close();
         }