@introspection-ai/recipes 0.13.0 → 0.14.1

package/dist/mcp-chunks/chunk-2XL7MG7R.js

@@ -0,0 +1,272 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/fs-json.js
+import crypto from "node:crypto";
+import { constants } from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+var DEFAULT_LOCK_TIMEOUT_MS = 3e4;
+var LOCK_POLL_MS = 25;
+var MALFORMED_LOCK_STALE_MS = 1e3;
+var MAX_SYMLINK_DEPTH = 40;
+var DEFAULT_ATOMIC_FILE_MODE = 384;
+var localLockTails = /* @__PURE__ */ new Map();
+async function readJsonFile(filePath) {
+  try {
+    const content = await fs.readFile(filePath, "utf8");
+    return JSON.parse(content);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return void 0;
+    }
+    throw error;
+  }
+}
+async function writeTextFileAtomic(filePath, data) {
+  const target = await resolveAtomicWriteTarget(filePath);
+  await fs.mkdir(path.dirname(target.path), { recursive: true });
+  const tempPath = path.join(path.dirname(target.path), `.${path.basename(target.path)}.${process.pid}.${Date.now()}.${crypto.randomUUID()}.tmp`);
+  try {
+    if (target.mode !== void 0) {
+      await fs.access(target.path, constants.W_OK);
+    }
+    await fs.writeFile(tempPath, data, {
+      encoding: "utf8",
+      flag: "wx",
+      mode: target.mode ?? DEFAULT_ATOMIC_FILE_MODE
+    });
+    if (target.mode !== void 0) {
+      await fs.chmod(tempPath, target.mode);
+    }
+    await fs.rename(tempPath, target.path);
+  } catch (error) {
+    await fs.unlink(tempPath).catch(() => {
+    });
+    if (target.mode !== void 0 && isPermissionError(error)) {
+      await fs.writeFile(filePath, data, "utf8");
+      return;
+    }
+    throw error;
+  }
+}
+async function writeJsonFile(filePath, data) {
+  await writeTextFileAtomic(filePath, JSON.stringify(data, null, 2));
+}
+async function withFileLock(filePath, task, options = {}) {
+  const lockTargetPath = await resolvePathFollowingSymlinks(filePath);
+  const timeoutMs = options.timeoutMs ?? DEFAULT_LOCK_TIMEOUT_MS;
+  const startedAt = Date.now();
+  return withLocalLock(lockTargetPath, timeoutMs, async () => {
+    await fs.mkdir(path.dirname(lockTargetPath), { recursive: true });
+    let lockPath = `${lockTargetPath}.lock`;
+    const fallbackLockPath = lockTargetPath !== filePath ? `${filePath}.lock` : void 0;
+    let acquired = false;
+    while (!acquired) {
+      try {
+        await fs.writeFile(lockPath, `${process.pid}
+${(/* @__PURE__ */ new Date()).toISOString()}
+`, {
+          encoding: "utf8",
+          flag: "wx"
+        });
+        acquired = true;
+        break;
+      } catch (error) {
+        if (fallbackLockPath && lockPath !== fallbackLockPath && isPermissionError(error)) {
+          await fs.mkdir(path.dirname(fallbackLockPath), { recursive: true });
+          lockPath = fallbackLockPath;
+          continue;
+        }
+        if (error.code !== "EEXIST") {
+          throw error;
+        }
+        if (await removeRecoverableLock(lockPath)) {
+          continue;
+        }
+        if (Date.now() - startedAt > timeoutMs) {
+          throw new Error(`Timed out waiting for file lock ${lockPath}`, { cause: error });
+        }
+        await sleep(LOCK_POLL_MS);
+      }
+    }
+    try {
+      return await task();
+    } finally {
+      await fs.unlink(lockPath).catch((error) => {
+        if (error.code !== "ENOENT") {
+          throw error;
+        }
+      });
+    }
+  });
+}
+function isPermissionError(error) {
+  const code = error.code;
+  return code === "EACCES" || code === "EPERM";
+}
+async function sleep(ms) {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function withLocalLock(key, timeoutMs, task) {
+  const previous = localLockTails.get(key) ?? Promise.resolve();
+  let release;
+  const current = new Promise((resolve) => {
+    release = resolve;
+  });
+  const tail = previous.then(() => current);
+  localLockTails.set(key, tail);
+  try {
+    await waitForLocalLock(previous, timeoutMs, key);
+    return await task();
+  } finally {
+    release();
+    void tail.then(() => {
+      if (localLockTails.get(key) === tail) {
+        localLockTails.delete(key);
+      }
+    });
+  }
+}
+async function waitForLocalLock(previous, timeoutMs, key) {
+  let timer;
+  try {
+    await Promise.race([
+      previous,
+      new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error(`Timed out waiting for file lock ${key}.lock`)), Math.max(0, timeoutMs));
+      })
+    ]);
+  } finally {
+    if (timer) {
+      clearTimeout(timer);
+    }
+  }
+}
+async function resolveAtomicWriteTarget(filePath) {
+  try {
+    const stats = await fs.lstat(filePath);
+    if (stats.isSymbolicLink()) {
+      const targetPath = await resolvePathFollowingSymlinks(filePath);
+      return { path: targetPath, mode: await readMode(targetPath) };
+    }
+    return { path: filePath, mode: stats.mode & 511 };
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return { path: filePath };
+    }
+    throw error;
+  }
+}
+async function resolvePathFollowingSymlinks(filePath) {
+  let currentPath = await canonicalizeParentDirectory(filePath);
+  for (let depth = 0; depth < MAX_SYMLINK_DEPTH; depth += 1) {
+    let stats;
+    try {
+      stats = await fs.lstat(currentPath);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return await canonicalizeParentDirectory(currentPath);
+      }
+      throw error;
+    }
+    if (!stats.isSymbolicLink()) {
+      return currentPath;
+    }
+    const link = await fs.readlink(currentPath);
+    currentPath = await canonicalizeParentDirectory(path.isAbsolute(link) ? link : path.resolve(path.dirname(currentPath), link));
+  }
+  throw new Error(`Too many symbolic links while resolving ${filePath}`);
+}
+async function canonicalizeParentDirectory(filePath) {
+  try {
+    return path.join(await fs.realpath(path.dirname(filePath)), path.basename(filePath));
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return filePath;
+    }
+    throw error;
+  }
+}
+async function readMode(filePath) {
+  try {
+    const stats = await fs.stat(filePath);
+    return stats.mode & 511;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return void 0;
+    }
+    throw error;
+  }
+}
+async function removeRecoverableLock(lockPath) {
+  const breakerPath = `${lockPath}.break`;
+  try {
+    await fs.writeFile(breakerPath, `${process.pid}
+${(/* @__PURE__ */ new Date()).toISOString()}
+`, {
+      encoding: "utf8",
+      flag: "wx"
+    });
+  } catch (error) {
+    if (error.code !== "EEXIST") {
+      return false;
+    }
+    if (!await isLockRecoverable(breakerPath)) {
+      return false;
+    }
+    await fs.unlink(breakerPath).catch(() => {
+    });
+    return false;
+  }
+  try {
+    if (!await isLockRecoverable(lockPath)) {
+      return false;
+    }
+    await fs.unlink(lockPath);
+    return true;
+  } catch (error) {
+    return error.code === "ENOENT";
+  } finally {
+    await fs.unlink(breakerPath).catch(() => {
+    });
+  }
+}
+async function isLockRecoverable(lockPath) {
+  let contents;
+  try {
+    contents = await fs.readFile(lockPath, "utf8");
+  } catch (error) {
+    return error.code === "ENOENT";
+  }
+  if (contents.length === 0) {
+    return await isMalformedLockStale(lockPath);
+  }
+  const pid = Number.parseInt(contents.split(/\r?\n/, 1)[0] ?? "", 10);
+  if (Number.isInteger(pid) && pid > 0) {
+    return !isProcessRunning(pid);
+  }
+  return await isMalformedLockStale(lockPath);
+}
+function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+async function isMalformedLockStale(lockPath) {
+  try {
+    const stats = await fs.stat(lockPath);
+    return Date.now() - stats.mtimeMs > MALFORMED_LOCK_STALE_MS;
+  } catch {
+    return false;
+  }
+}
+
+export {
+  readJsonFile,
+  writeTextFileAtomic,
+  writeJsonFile,
+  withFileLock
+};